logoxide-cli 0.1.1

lx, logoxide's command line: Bibles, commentaries, lexicons, books, and media as versioned packages
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

//! `lx read` and `lx compare`: passages from the project's Bibles

use logoxide_app::{Style, Text};

use crate::{app, cli::Cli, print_json};

/// A passage's text as JSON: a string, or null when the Bible has none there
fn text_json(text: Option<&Text>) -> serde_json::Value {
    match text {
        None => serde_json::Value::Null,
        Some(text) => serde_json::Value::String(text.text.clone()),
    }
}

/// Prints a passage from one of the project's Bibles
pub(crate) fn read(cli: &Cli, reference: &str, style: Style, json: bool) -> logoxide::Result<()> {
    let project = cli.project(&cli.library())?;
    let read = app().read(&project, reference, &style)?;
    if json {
        return print_json(&serde_json::json!({
            "bible": read.bible,
            "abbreviation": read.abbreviation,
            "reference": read.reference,
            "osis": read.osis,
            "versification": read.versification,
            "text": text_json(read.text.as_ref()),
        }));
    }
    outln!("{} ({})", read.reference, read.abbreviation);
    match &read.text {
        Some(text) => outln!("{}", text.text),
        None => outln!("(no text in {})", read.abbreviation),
    }
    Ok(())
}

/// Prints a passage in several of the project's Bibles, each in its own numbering
pub(crate) fn compare(
    cli: &Cli,
    reference: &str,
    bibles: &[String],
    style: Style,
    json: bool,
) -> logoxide::Result<()> {
    let project = cli.project(&cli.library())?;
    let compared = app().compare(&project, reference, bibles, &style)?;
    if json {
        let all: Vec<serde_json::Value> = (compared.iter())
            .map(|c| {
                serde_json::json!({
                    "bible": c.bible,
                    "abbreviation": c.abbreviation,
                    "reference": c.reference,
                    "versification": c.versification,
                    "mapped": c.mapped,
                    "missing": c.missing,
                    "text": text_json(c.text.as_ref()),
                })
            })
            .collect();
        return print_json(&all);
    }
    for (i, c) in compared.iter().enumerate() {
        if i > 0 {
            outln!();
        }
        match c.reference.is_empty() {
            true => outln!(
                "{}: (no counterpart in {})",
                c.abbreviation,
                c.versification
            ),
            false if c.mapped => outln!(
                "{} ({}, numbered {})",
                c.reference,
                c.abbreviation,
                c.versification
            ),
            false => outln!("{} ({})", c.reference, c.abbreviation),
        }
        if !c.reference.is_empty() {
            match &c.text {
                Some(text) => outln!("{}", text.text),
                None => outln!("(no text in {})", c.abbreviation),
            }
        }
        if !c.missing.is_empty() {
            outln!("not in {}: {}", c.abbreviation, c.missing);
        }
    }
    Ok(())
}