aspero 0.3.2

Find, resolve and verify scholarly literature from the command line
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! One module per subcommand, plus the plumbing they share.
//!
//! A command returns `Ok(exit)` when it ran (even if some items were not
//! found: those outcomes are in its output) and `Err(Failure)` when it could
//! not run at all.

pub mod cache;
pub mod check;
pub mod claim;
pub mod lookup;
pub mod resolve;
pub mod scan;
pub mod search;
pub mod verify;

use std::io::Read;

use aspero_core::{ProviderId, Usage};
use aspero_engine::EngineError;
use serde_json::Value;

use crate::args::Format;
use crate::exit::Exit;

/// A command that couldn't run at all (as opposed to per-item outcomes).
#[derive(Debug)]
pub struct Failure {
    pub exit: Exit,
    pub message: String,
}

impl Failure {
    pub fn usage(message: impl Into<String>) -> Self {
        Failure {
            exit: Exit::Usage,
            message: message.into(),
        }
    }
}

impl From<EngineError> for Failure {
    fn from(e: EngineError) -> Self {
        Failure {
            exit: Exit::from_category(e.category()),
            message: e.to_string(),
        }
    }
}

/// Resolved output settings. `format` is never `Auto` here.
#[derive(Debug, Clone, Copy)]
pub struct Out {
    pub format: Format,
    pub full: bool,
    pub abstracts: bool,
}

pub fn read_stdin() -> Result<String, Failure> {
    let mut buf = String::new();
    std::io::stdin()
        .read_to_string(&mut buf)
        .map_err(|e| Failure::usage(format!("could not read stdin: {e}")))?;
    Ok(buf)
}

/// Quotes `s` for a POSIX shell, leaving plain words as they are.
pub fn shell_quote(s: &str) -> String {
    let plain = |c: char| c.is_ascii_alphanumeric() || "-_./:=+,@%".contains(c);
    if !s.is_empty() && s.chars().all(plain) {
        s.to_owned()
    } else {
        format!("'{}'", s.replace('\'', r"'\''"))
    }
}

/// A whole JSON document, pretty-printed.
pub fn print(value: &Value) {
    println!(
        "{}",
        serde_json::to_string_pretty(value).expect("JSON values serialise")
    );
}

/// `base` with `extra`'s fields added (both JSON objects).
pub fn merged(mut base: Value, extra: Value) -> Value {
    if let (Value::Object(b), Value::Object(e)) = (&mut base, extra) {
        b.extend(e);
    }
    base
}

/// One JSON Lines record.
pub fn print_line(value: &Value) {
    println!("{value}");
}

/// Adds `usage` to a per-provider total.
pub fn merge_usage(totals: &mut Vec<(ProviderId, Usage)>, provider: &ProviderId, usage: Usage) {
    match totals.iter_mut().find(|(p, _)| p == provider) {
        Some((_, total)) => *total = total.then(usage),
        None => totals.push((provider.clone(), usage)),
    }
}