mod citekey;
use chrono::NaiveDate;
use citekey::{CiteKey, Mismatch};
use clap::{Args, Parser, Subcommand, ValueEnum};
use crossref_client::{
AsyncIterator, CnFormat, Crossref, FieldQuery, FilterParseError, FundersFilter, FundersQuery,
JournalsQuery, LicensesQuery, MembersFilter, MembersQuery, Order, ResultControl, Sort, Type,
Work, WorkResultControl, WorksFilter, WorksQuery,
};
use serde::Serialize;
use std::{fs, io::Write, path::PathBuf, process::ExitCode, str::FromStr};
#[derive(Debug, Parser)]
#[command(
name = "crossref",
about = "Access the crossref API from the command line.",
version
)]
struct App {
#[command(flatten)]
client: ClientOpts,
#[command(flatten)]
out: Out,
#[command(subcommand)]
command: Command,
}
#[derive(Debug, Subcommand)]
enum Command {
Works {
#[arg(short, long)]
id: Option<String>,
#[arg(short, long)]
deep_page: bool,
#[command(flatten)]
opts: WorksOpts,
#[command(subcommand)]
combined: Option<Combined>,
},
Cite {
#[arg(required = true, value_name = "KEY")]
keys: Vec<CiteKey>,
#[command(flatten)]
opts: CiteOpts,
},
Funders {
#[arg(short, long)]
id: Option<String>,
#[command(flatten)]
opts: FundersOpts,
},
Members {
#[arg(short, long)]
id: Option<String>,
#[command(flatten)]
opts: MembersOpts,
},
Journals {
#[arg(short, long)]
id: Option<String>,
#[command(flatten)]
opts: ListOpts,
},
Licenses {
#[command(flatten)]
opts: ListOpts,
},
Prefixes {
#[arg(short, long)]
id: String,
},
Types {
#[arg(short, long)]
id: Option<Type>,
},
Transform {
doi: String,
#[arg(long, value_enum, default_value_t = Format::Bibtex)]
format: Format,
#[arg(long, default_value = "apa")]
style: String,
#[arg(long)]
locale: Option<String>,
},
Styles,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
enum Format {
RdfXml,
Turtle,
CiteprocJson,
CiteprocJsonIsh,
Ris,
Bibtex,
CrossrefXml,
CrossrefTdm,
Citation,
}
impl Format {
fn into_cn_format(self, style: String, locale: Option<String>) -> CnFormat {
match self {
Format::RdfXml => CnFormat::RdfXml,
Format::Turtle => CnFormat::Turtle,
Format::CiteprocJson => CnFormat::CiteProcJson,
Format::CiteprocJsonIsh => CnFormat::CiteProcJsonIsh,
Format::Ris => CnFormat::Ris,
Format::Bibtex => CnFormat::BibTex,
Format::CrossrefXml => CnFormat::CrossrefXml,
Format::CrossrefTdm => CnFormat::CrossrefTdm,
Format::Citation => CnFormat::Bibliography { style, locale },
}
}
}
#[derive(Debug, Subcommand)]
enum Combined {
Member { id: String },
Funder { id: String },
Journal { id: String },
Prefix { id: String },
Type { id: String },
}
#[derive(Debug, Args)]
struct Out {
#[arg(short, long, global = true)]
output: Option<PathBuf>,
#[arg(short, long, global = true)]
append: bool,
}
#[derive(Debug, Args)]
struct ClientOpts {
#[arg(long, global = true)]
user_agent: Option<String>,
#[arg(long, global = true)]
token: Option<String>,
#[arg(long, global = true)]
polite: Option<String>,
}
impl ClientOpts {
fn create_client(&self) -> crossref_client::Result<Crossref> {
Crossref::builder()
.user_agent(self.user_agent.as_deref())
.token(self.token.as_deref())
.polite(self.polite.as_deref())
.build()
}
}
#[derive(Debug, Args)]
struct ListOpts {
#[arg(short, long = "query")]
query_terms: Vec<String>,
#[arg(short, long)]
limit: Option<usize>,
#[arg(long)]
offset: Option<usize>,
}
impl ListOpts {
fn result_control(&self) -> Option<ResultControl> {
match (self.limit, self.offset) {
(Some(rows), Some(offset)) => Some(ResultControl::RowsOffset { rows, offset }),
(Some(rows), None) => Some(ResultControl::Rows(rows)),
(None, Some(offset)) => Some(ResultControl::Offset(offset)),
(None, None) => None,
}
}
}
#[derive(Debug, Clone)]
struct FieldQueryArg(FieldQuery);
impl FromStr for FieldQueryArg {
type Err = String;
fn from_str(arg: &str) -> Result<Self, Self::Err> {
let Some((field, term)) = arg.split_once('=') else {
return Err(format!("`{arg}` is not a `field=term` pair"));
};
if term.is_empty() {
return Err(format!("`{field}` was given no term to match"));
}
FieldQuery::from_field(field, term)
.map(FieldQueryArg)
.ok_or_else(|| {
format!(
"`{field}` is not a field crossref can be queried against. Try one of: {}",
FieldQuery::ALL_FIELDS.join(", ")
)
})
}
}
trait NamedFilter: Sized + Clone + Send + Sync + 'static {
const NAMES: &'static [&'static str];
fn from_pair(name: &str, value: Option<&str>) -> Result<Self, FilterParseError>;
}
impl NamedFilter for WorksFilter {
const NAMES: &'static [&'static str] = WorksFilter::ALL_NAMES;
fn from_pair(name: &str, value: Option<&str>) -> Result<Self, FilterParseError> {
WorksFilter::from_name(name, value)
}
}
impl NamedFilter for FundersFilter {
const NAMES: &'static [&'static str] = FundersFilter::ALL_NAMES;
fn from_pair(name: &str, value: Option<&str>) -> Result<Self, FilterParseError> {
FundersFilter::from_name(name, value)
}
}
impl NamedFilter for MembersFilter {
const NAMES: &'static [&'static str] = MembersFilter::ALL_NAMES;
fn from_pair(name: &str, value: Option<&str>) -> Result<Self, FilterParseError> {
MembersFilter::from_name(name, value)
}
}
#[derive(Debug, Clone)]
struct FilterArg<F>(F);
impl<F: NamedFilter> FromStr for FilterArg<F> {
type Err = String;
fn from_str(arg: &str) -> Result<Self, Self::Err> {
let (name, value) = match arg.split_once(':') {
Some((name, value)) => (name, Some(value)),
None => (arg, None),
};
F::from_pair(name, value)
.map(FilterArg)
.map_err(|err| match err {
FilterParseError::UnknownName { .. } => {
format!("{err}. Try one of: {}", F::NAMES.join(", "))
}
err => err.to_string(),
})
}
}
fn narrow<Q, F>(query: Q, filters: Vec<FilterArg<F>>, filter: impl Fn(Q, F) -> Q) -> Q {
filters
.into_iter()
.fold(query, |query, arg| filter(query, arg.0))
}
#[derive(Debug, Args)]
struct WorksOpts {
#[command(flatten)]
list: ListOpts,
#[arg(long, value_name = "CITATION")]
query_bibliographic: Option<String>,
#[arg(long, value_name = "TERM")]
query_title: Option<String>,
#[arg(long, value_name = "TERM")]
query_author: Option<String>,
#[arg(long, value_name = "FIELD=TERM")]
query_field: Vec<FieldQueryArg>,
#[arg(long, value_name = "NAME[:VALUE]")]
filter: Vec<FilterArg<WorksFilter>>,
#[arg(long)]
sort: Option<Sort>,
#[arg(long)]
order: Option<Order>,
#[arg(long)]
sample: Option<usize>,
}
impl WorksOpts {
fn field_queries(&self) -> Result<Vec<FieldQuery>, String> {
let named = [
self.query_bibliographic
.as_deref()
.map(FieldQuery::bibliographic),
self.query_title.as_deref().map(FieldQuery::title),
self.query_author.as_deref().map(FieldQuery::author),
];
let queries: Vec<_> = named
.into_iter()
.flatten()
.chain(self.query_field.iter().map(|arg| arg.0.clone()))
.collect();
for (at, query) in queries.iter().enumerate() {
if queries[..at]
.iter()
.any(|seen| seen.field() == query.field())
{
return Err(format!(
"`{}` was asked for twice; crossref matches a field against one term",
query.name()
));
}
}
Ok(queries)
}
fn into_query(self) -> Result<WorksQuery, String> {
let field_queries = self.field_queries()?;
let query = WorksQuery::empty()
.queries(&self.list.query_terms)
.field_queries(field_queries)
.sort(self.sort)
.order(self.order)
.sample(self.sample)
.result_control(self.list.result_control().map(WorkResultControl::Standard));
Ok(narrow(query, self.filter, WorksQuery::filter))
}
}
#[derive(Debug, Args)]
struct FundersOpts {
#[command(flatten)]
list: ListOpts,
#[arg(long, value_name = "NAME[:VALUE]")]
filter: Vec<FilterArg<FundersFilter>>,
}
impl FundersOpts {
fn into_query(self) -> FundersQuery {
let query = FundersQuery::empty()
.queries(&self.list.query_terms)
.result_control(self.list.result_control());
narrow(query, self.filter, FundersQuery::filter)
}
}
#[derive(Debug, Args)]
struct MembersOpts {
#[command(flatten)]
list: ListOpts,
#[arg(long, value_name = "NAME[:VALUE]")]
filter: Vec<FilterArg<MembersFilter>>,
}
impl MembersOpts {
fn into_query(self) -> MembersQuery {
let query = MembersQuery::empty()
.queries(&self.list.query_terms)
.result_control(self.list.result_control());
narrow(query, self.filter, MembersQuery::filter)
}
}
#[derive(Debug, Args)]
struct CiteOpts {
#[arg(long, default_value_t = 20, value_parser = clap::value_parser!(u16).range(1..=1000))]
candidates: u16,
#[arg(long, default_value_t = 1, value_name = "YEARS", value_parser = clap::value_parser!(u8).range(0..=50))]
year_window: u8,
#[arg(long, default_value_t = 12, value_parser = clap::value_parser!(u16).range(0..=500))]
spellings: u16,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "kebab-case")]
struct Resolution {
key: String,
surnames: Vec<String>,
year: i32,
et_al: bool,
verdict: Verdict,
#[serde(skip_serializing_if = "Option::is_none")]
matched_as: Option<Vec<String>>,
requests: usize,
#[serde(skip_serializing_if = "Option::is_none")]
doi: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
work: Option<Box<Work>>,
#[serde(skip_serializing_if = "Vec::is_empty")]
candidates: Vec<Candidate>,
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "kebab-case")]
enum Verdict {
Matched,
Ambiguous,
Unmatched,
}
#[derive(Debug, Serialize)]
struct Candidate {
#[serde(rename = "DOI")]
doi: String,
#[serde(skip_serializing_if = "Option::is_none")]
title: Option<String>,
authors: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
year: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
score: Option<f32>,
#[serde(skip_serializing_if = "Vec::is_empty")]
mismatches: Vec<Mismatch>,
}
impl Candidate {
fn new(work: &Work, mismatches: Vec<Mismatch>) -> Self {
Candidate {
doi: work.doi.clone(),
title: work.title.first().cloned(),
authors: citekey::families(work)
.into_iter()
.map(str::to_string)
.collect(),
year: citekey::published_year(work),
score: work.score,
mismatches,
}
}
}
impl Resolution {
fn about(key: &CiteKey, requests: usize, verdict: Verdict) -> Self {
Resolution {
key: key.key().to_string(),
surnames: key.surnames().to_vec(),
year: key.year(),
et_al: key.et_al(),
verdict,
matched_as: None,
requests,
doi: None,
work: None,
candidates: Vec::new(),
}
}
}
struct Attempt {
spelling: Option<Vec<String>>,
query: WorksQuery,
}
fn attempts(key: &CiteKey, opts: &CiteOpts) -> Vec<Attempt> {
let as_written = [
author_query(key.surnames(), key, opts),
bibliographic_query(key, opts),
]
.map(|query| Attempt {
spelling: None,
query,
});
as_written
.into_iter()
.chain(
key.spellings()
.into_iter()
.take(usize::from(opts.spellings))
.map(|spelling| Attempt {
query: author_query(&spelling, key, opts),
spelling: Some(spelling),
}),
)
.collect()
}
fn author_query(surnames: &[String], key: &CiteKey, opts: &CiteOpts) -> WorksQuery {
let authors = FieldQuery::author(surnames.join(" "));
published_around(WorksQuery::empty().field_query(authors), key, opts)
}
fn bibliographic_query(key: &CiteKey, opts: &CiteOpts) -> WorksQuery {
let citation = format!("{} {}", key.surnames().join(" "), key.year());
let citation = FieldQuery::bibliographic(citation);
published_around(WorksQuery::empty().field_query(citation), key, opts)
}
fn published_around(query: WorksQuery, key: &CiteKey, opts: &CiteOpts) -> WorksQuery {
let within = i32::from(opts.year_window);
let date = |year, month, day| {
NaiveDate::from_ymd_opt(year, month, day).expect("a year that parsed bounds a real date")
};
query
.filter(WorksFilter::FromPubDate(date(key.year() - within, 1, 1)))
.filter(WorksFilter::UntilPubDate(date(key.year() + within, 12, 31)))
.result_control(WorkResultControl::Standard(ResultControl::Rows(
usize::from(opts.candidates),
)))
}
async fn resolve(
key: &CiteKey,
opts: &CiteOpts,
client: &Crossref,
) -> crossref_client::Result<Resolution> {
let within = i32::from(opts.year_window);
let mut requests = 0;
let mut turned_down: Vec<Candidate> = Vec::new();
for attempt in attempts(key, opts) {
let found = client.works(attempt.query).await?;
requests += 1;
let mut vouched: Vec<Work> = Vec::new();
for work in found.items {
let mismatches = key.mismatches(&work, within);
if mismatches.is_empty() {
vouched.push(work);
} else if !turned_down.iter().any(|seen| seen.doi == work.doi) {
turned_down.push(Candidate::new(&work, mismatches));
}
}
if vouched.len() == 1 {
let work = vouched.pop().expect("the one work that was vouched for");
let mut resolution = Resolution::about(key, requests, Verdict::Matched);
resolution.matched_as = attempt.spelling;
resolution.doi = Some(work.doi.clone());
resolution.work = Some(Box::new(work));
return Ok(resolution);
}
if !vouched.is_empty() {
let mut resolution = Resolution::about(key, requests, Verdict::Ambiguous);
resolution.matched_as = attempt.spelling;
resolution.candidates = vouched
.iter()
.map(|work| Candidate::new(work, Vec::new()))
.collect();
return Ok(resolution);
}
}
let mut resolution = Resolution::about(key, requests, Verdict::Unmatched);
turned_down.truncate(3);
resolution.candidates = turned_down;
Ok(resolution)
}
impl Command {
async fn run<W: Write>(
self,
mut writer: W,
client: &Crossref,
) -> Result<ExitCode, Box<dyn std::error::Error>> {
match self {
Command::Types { id } => match id {
Some(id) => serde_json::to_writer_pretty(writer, &client.type_(&id).await?)?,
None => serde_json::to_writer_pretty(writer, &client.types().await?)?,
},
Command::Prefixes { id } => {
serde_json::to_writer_pretty(writer, &client.prefix(&id).await?)?
}
Command::Styles => serde_json::to_writer_pretty(writer, &client.styles().await?)?,
Command::Transform {
doi,
format,
style,
locale,
} => {
let body = client
.transform(&doi, &format.into_cn_format(style, locale))
.await?;
writer.write_all(body.as_bytes())?;
}
Command::Cite { keys, opts } => {
let mut resolutions = Vec::with_capacity(keys.len());
for key in &keys {
resolutions.push(resolve(key, &opts, client).await?);
}
let resolved = resolutions
.iter()
.all(|resolution| matches!(resolution.verdict, Verdict::Matched));
serde_json::to_writer_pretty(writer, &resolutions)?;
return Ok(if resolved {
ExitCode::SUCCESS
} else {
ExitCode::FAILURE
});
}
Command::Journals { id, opts } => match id {
Some(id) => serde_json::to_writer_pretty(writer, &client.journal(&id).await?)?,
None => {
let query = JournalsQuery::empty()
.queries(&opts.query_terms)
.result_control(opts.result_control());
serde_json::to_writer_pretty(writer, &client.journals(query).await?)?
}
},
Command::Licenses { opts } => {
let query = LicensesQuery::empty()
.queries(&opts.query_terms)
.result_control(opts.result_control());
serde_json::to_writer_pretty(writer, &client.licenses(query).await?)?
}
Command::Members { id, opts } => match id {
Some(id) => serde_json::to_writer_pretty(writer, &client.member(&id).await?)?,
None => {
let members = client.members(opts.into_query()).await?;
serde_json::to_writer_pretty(writer, &members)?
}
},
Command::Funders { id, opts } => match id {
Some(id) => serde_json::to_writer_pretty(writer, &client.funder(&id).await?)?,
None => {
let funders = client.funders(opts.into_query()).await?;
serde_json::to_writer_pretty(writer, &funders)?
}
},
Command::Works {
id,
opts,
combined,
deep_page,
} => {
if let Some(id) = &id {
serde_json::to_writer_pretty(writer, &client.work(id).await?)?;
return Ok(ExitCode::SUCCESS);
}
let query = opts.into_query()?;
let query = match combined {
Some(Combined::Journal { id }) => {
query.into_combined_query::<crossref_client::Journals>(&id)
}
Some(Combined::Type { id }) => {
query.into_combined_query::<crossref_client::Types>(&id)
}
Some(Combined::Funder { id }) => {
query.into_combined_query::<crossref_client::Funders>(&id)
}
Some(Combined::Member { id }) => {
query.into_combined_query::<crossref_client::Members>(&id)
}
Some(Combined::Prefix { id }) => {
query.into_combined_query::<crossref_client::Prefixes>(&id)
}
None => query.into(),
};
if deep_page {
let mut pages = client.deep_page(query);
let mut works = Vec::new();
while let Some(page) = pages.next().await {
works.extend(page?.items);
}
serde_json::to_writer_pretty(writer, &works)?
} else {
serde_json::to_writer_pretty(writer, &client.works(query).await?)?
}
}
}
Ok(ExitCode::SUCCESS)
}
}
#[tokio::main]
async fn main() -> Result<ExitCode, Box<dyn std::error::Error>> {
tracing_subscriber::fmt()
.with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
.init();
let app = App::parse();
let client = app.client.create_client()?;
match &app.out.output {
Some(path) => {
let file = if app.out.append && path.exists() {
fs::OpenOptions::new().append(true).open(path)?
} else {
fs::File::create(path)?
};
app.command.run(file, &client).await
}
None => app.command.run(std::io::stdout(), &client).await,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crossref_client::CrossrefRoute;
fn works_route(args: &[&str]) -> Result<String, String> {
let app = App::try_parse_from(args).map_err(|err| err.to_string())?;
let Command::Works { opts, .. } = app.command else {
panic!("`{args:?}` did not parse into a works command");
};
let query = opts.into_query()?;
Ok(query.route().expect("a works query always renders"))
}
#[test]
fn a_bibliographic_query_reaches_crossrefs_reference_matching() {
let route = works_route(&[
"crossref",
"works",
"--query-bibliographic",
"Feynman 1960 There's Plenty of Room at the Bottom",
])
.unwrap();
assert!(
route.contains("query.bibliographic=Feynman%201960"),
"{route}"
);
}
#[test]
fn the_named_field_flags_render_their_own_fields() {
let route = works_route(&[
"crossref",
"works",
"--query-title",
"room at the bottom",
"--query-author",
"feynman",
])
.unwrap();
assert!(
route.contains("query.title=room%20at%20the%20bottom"),
"{route}"
);
assert!(route.contains("query.author=feynman"), "{route}");
}
#[test]
fn a_field_query_can_name_any_field_the_flags_do_not() {
let route = works_route(&[
"crossref",
"works",
"--query-field",
"container-title=Nature",
"--query-field",
"publisher-name=Elsevier",
])
.unwrap();
assert!(route.contains("query.container-title=Nature"), "{route}");
assert!(route.contains("query.publisher-name=Elsevier"), "{route}");
}
#[test]
fn field_queries_sit_alongside_the_free_form_terms() {
let route = works_route(&[
"crossref",
"works",
"--query",
"nanotechnology",
"--query-author",
"feynman",
"--limit",
"5",
])
.unwrap();
assert!(route.contains("query=nanotechnology"), "{route}");
assert!(route.contains("query.author=feynman"), "{route}");
assert!(route.contains("rows=5"), "{route}");
}
#[test]
fn a_works_query_without_field_flags_sends_none() {
let route = works_route(&["crossref", "works", "--query", "nanotechnology"]).unwrap();
assert!(!route.contains("query."), "{route}");
}
#[test]
fn an_unknown_field_is_rejected_with_the_fields_that_do_exist() {
let err = works_route(&[
"crossref",
"works",
"--query-field",
"pubisher-name=Elsevier",
])
.unwrap_err();
assert!(err.contains("pubisher-name"), "{err}");
assert!(err.contains("publisher-name"), "{err}");
}
#[test]
fn a_field_query_without_a_term_is_rejected() {
let err = works_route(&["crossref", "works", "--query-field", "author"]).unwrap_err();
assert!(err.contains("`author` is not a `field=term` pair"), "{err}");
let err = works_route(&["crossref", "works", "--query-field", "author="]).unwrap_err();
assert!(err.contains("no term to match"), "{err}");
}
#[test]
fn one_field_asked_for_twice_is_rejected_rather_than_guessed_at() {
let err = works_route(&[
"crossref",
"works",
"--query-author",
"feynman",
"--query-field",
"author=gell-mann",
])
.unwrap_err();
assert!(err.contains("query.author"), "{err}");
let err = works_route(&[
"crossref",
"works",
"--query-field",
"editor=hey",
"--query-field",
"editor=walther",
])
.unwrap_err();
assert!(err.contains("query.editor"), "{err}");
}
#[test]
fn filters_narrow_a_works_query_and_and_together() {
let route = works_route(&[
"crossref",
"works",
"--query",
"salmon",
"--filter",
"from-pub-date:2020-01-01",
"--filter",
"until-pub-date:2021-12-31",
"--filter",
"has-abstract",
])
.unwrap();
assert!(route.contains("from-pub-date"), "{route}");
assert!(route.contains("2020-01-01"), "{route}");
assert!(route.contains("until-pub-date"), "{route}");
assert!(route.contains("2021-12-31"), "{route}");
assert!(route.contains("has-abstract"), "{route}");
assert!(route.contains("true"), "{route}");
}
#[test]
fn a_filter_the_route_does_not_take_is_rejected_with_the_ones_it_does() {
let err = works_route(&["crossref", "works", "--filter", "has-astract"]).unwrap_err();
assert!(err.contains("has-astract"), "{err}");
assert!(err.contains("has-abstract"), "{err}");
}
#[test]
fn a_filter_value_crossref_could_not_read_is_rejected_before_it_is_sent() {
let err =
works_route(&["crossref", "works", "--filter", "from-pub-date:2020"]).unwrap_err();
assert!(err.contains("`2020` is not a value"), "{err}");
let err = works_route(&["crossref", "works", "--filter", "issn"]).unwrap_err();
assert!(err.contains("needs a value"), "{err}");
let err =
works_route(&["crossref", "works", "--filter", "has-abstract:false"]).unwrap_err();
assert!(err.contains("takes no value"), "{err}");
}
#[test]
fn a_filter_value_that_cannot_be_sent_is_reported_by_the_query() {
let parsed = App::try_parse_from(["crossref", "works", "--filter", "container-title:a,b"]);
let Ok(App {
command: Command::Works { opts, .. },
..
}) = parsed
else {
panic!("a filter with a comma parses; it is the sending that fails")
};
assert!(opts.into_query().unwrap().route().is_err());
}
#[test]
fn the_routes_that_narrow_by_nothing_take_no_filter_at_all() {
for route in ["journals", "licenses"] {
let parsed = App::try_parse_from(["crossref", route, "--filter", "has-abstract"]);
assert!(parsed.is_err(), "`crossref {route}` took --filter");
}
}
#[test]
fn funders_and_members_narrow_by_their_own_filters() {
let route = |args: &[&str]| {
let app = App::try_parse_from(args).expect("a list command line");
match app.command {
Command::Funders { opts, .. } => opts.into_query().route(),
Command::Members { opts, .. } => opts.into_query().route(),
_ => panic!("`{args:?}` is neither funders nor members"),
}
.expect("a list query renders")
};
let funders = route(&[
"crossref",
"funders",
"-q",
"research",
"--filter",
"location:Norway",
]);
assert!(funders.contains("query=research"), "{funders}");
assert!(funders.contains("location"), "{funders}");
assert!(funders.contains("Norway"), "{funders}");
let members = route(&[
"crossref",
"members",
"--filter",
"prefix:10.1016",
"--filter",
"current-doi-count:1000",
]);
assert!(members.contains("prefix"), "{members}");
assert!(members.contains("10.1016"), "{members}");
assert!(members.contains("current-doi-count"), "{members}");
}
#[test]
fn a_filter_belonging_to_another_route_is_refused_with_this_routes_own() {
let err = App::try_parse_from(["crossref", "funders", "--filter", "has-abstract"])
.expect_err("a works filter on /funders")
.to_string();
assert!(err.contains("has-abstract"), "{err}");
assert!(err.contains("location"), "{err}");
let err = works_route(&["crossref", "works", "--filter", "location:Norway"]).unwrap_err();
assert!(err.contains("not a filter this route takes"), "{err}");
let err = App::try_parse_from(["crossref", "members", "--filter", "location:Norway"])
.expect_err("a funders filter on /members")
.to_string();
assert!(err.contains("backfile-doi-count"), "{err}");
}
#[test]
fn a_members_filter_counts_dois_and_will_not_take_a_word_for_it() {
let err =
App::try_parse_from(["crossref", "members", "--filter", "current-doi-count:many"])
.expect_err("a count that is not a number")
.to_string();
assert!(err.contains("`many` is not a value"), "{err}");
}
fn cite_attempts(args: &[&str]) -> Vec<String> {
let app = App::try_parse_from(args).expect("a cite command line");
let Command::Cite { keys, opts } = app.command else {
panic!("`{args:?}` did not parse into a cite command");
};
let key = keys.first().expect("clap requires a key");
attempts(key, &opts)
.into_iter()
.map(|attempt| attempt.query.route().expect("a works query renders"))
.collect()
}
#[test]
fn a_key_is_first_asked_for_as_authors_published_around_the_year() {
let routes = cite_attempts(&["crossref", "cite", "@LindforsJakobsen2022"]);
assert!(
routes[0].contains("query.author=Lindfors%20Jakobsen"),
"{}",
routes[0]
);
assert!(routes[0].contains("2021-01-01"), "{}", routes[0]);
assert!(routes[0].contains("2023-12-31"), "{}", routes[0]);
assert!(routes[0].contains("rows=20"), "{}", routes[0]);
}
#[test]
fn the_year_window_widens_both_ends_of_the_search() {
let routes = cite_attempts(&["crossref", "cite", "@Lindfors2022", "--year-window", "3"]);
assert!(routes[0].contains("2019-01-01"), "{}", routes[0]);
assert!(routes[0].contains("2025-12-31"), "{}", routes[0]);
}
#[test]
fn the_key_is_then_asked_for_as_a_whole_citation() {
let routes = cite_attempts(&["crossref", "cite", "@LindforsJakobsen2022"]);
assert!(
routes[1].contains("query.bibliographic=Lindfors%20Jakobsen%202022"),
"{}",
routes[1]
);
assert!(!routes[1].contains("query.author"), "{}", routes[1]);
}
#[test]
fn the_accented_spellings_are_guessed_at_last_and_likeliest_first() {
let routes = cite_attempts(&["crossref", "cite", "@Floysand2021"]);
assert_eq!(2 + 12, routes.len());
assert!(
routes[2].contains("query.author=Fl%C3%B8ysand"),
"{}",
routes[2]
);
}
#[test]
fn the_guessing_can_be_turned_off() {
let routes = cite_attempts(&["crossref", "cite", "@Floysand2021", "--spellings", "0"]);
assert_eq!(2, routes.len());
}
#[test]
fn a_key_that_names_no_one_is_rejected_before_a_request_is_spent() {
let err = App::try_parse_from(["crossref", "cite", "@2022"])
.expect_err("a key naming nobody")
.to_string();
assert!(err.contains("names no author"), "{err}");
}
#[test]
fn a_verdict_reads_as_the_word_for_it() {
assert_eq!(
"\"matched\"",
serde_json::to_string(&Verdict::Matched).unwrap()
);
assert_eq!(
"\"ambiguous\"",
serde_json::to_string(&Verdict::Ambiguous).unwrap()
);
assert_eq!(
"\"unmatched\"",
serde_json::to_string(&Verdict::Unmatched).unwrap()
);
}
#[test]
fn the_other_routes_do_not_take_field_queries() {
for route in ["journals", "members", "funders", "licenses"] {
let parsed = App::try_parse_from(["crossref", route, "--query-title", "ecology"]);
assert!(parsed.is_err(), "`crossref {route}` took --query-title");
}
}
#[test]
fn every_field_is_reachable_through_query_field() {
for field in FieldQuery::ALL_FIELDS {
let arg = format!("{field}=term");
let route = works_route(&["crossref", "works", "--query-field", &arg])
.unwrap_or_else(|err| panic!("`--query-field {arg}` was rejected: {err}"));
assert!(route.contains(&format!("query.{field}=term")), "{route}");
}
}
}