cooklang-chef 0.4.1

CLI to manage cooklang recipes
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
104
105
106
107
108
109
110
111
112
113

use anstream::println;
use anyhow::Result;
use camino::Utf8PathBuf;
use clap::{Args, ValueEnum};
use cooklang::aisle::AisleConf;

use crate::util::write_to_output;

#[derive(Debug, Args)]
pub struct ConfArgs {
    /// Output file, none for stdout.
    #[arg(short, long)]
    output: Option<Utf8PathBuf>,

    /// Output format
    #[arg(short, long, value_enum)]
    format: Option<OutputFormat>,

    /// Pretty output format, if available
    #[arg(long)]
    pretty: bool,

    /// Sort the aisle file alphabetically
    #[arg(long)]
    sorted: bool,

    /// Only get a count of entries
    #[arg(short = 'n', long, conflicts_with_all = ["output", "format"])]
    count: bool,
}

#[derive(Debug, ValueEnum, Clone, Copy)]
enum OutputFormat {
    Human,
    Conf,
    Json,
}

pub fn run(mut aisle: AisleConf, args: ConfArgs) -> Result<()> {
    if args.count {
        let mut table = tabular::Table::new("{:<}  {:<}")
            .with_heading(format!("total {}", aisle.categories.len()));
        for cat in &aisle.categories {
            table.add_row(tabular::row!(cat.name, cat.ingredients.len()));
        }
        println!("{table}");
        return Ok(());
    }

    if args.sorted {
        aisle.categories.sort_unstable_by_key(|c| c.name);
        for c in &mut aisle.categories {
            for i in &mut c.ingredients {
                i.names.sort_unstable();
            }
            c.ingredients
                .sort_unstable_by_key(|i| i.names.first().copied().unwrap_or(""))
        }
    }

    let format = args.format.unwrap_or_else(|| match &args.output {
        Some(p) => match p.extension() {
            Some("json") => OutputFormat::Json,
            _ => OutputFormat::Conf,
        },
        None => OutputFormat::Human,
    });

    write_to_output(args.output.as_deref(), |writer| {
        match format {
            OutputFormat::Human => print_aile_human(&aisle, writer)?,
            OutputFormat::Conf => cooklang::aisle::write(&aisle, writer)?,
            OutputFormat::Json => {
                if args.pretty {
                    serde_json::to_writer_pretty(writer, &aisle)?;
                } else {
                    serde_json::to_writer(writer, &aisle)?;
                }
            }
        };
        Ok(())
    })?;

    Ok(())
}

fn print_aile_human(aisle: &AisleConf, mut writer: impl std::io::Write) -> std::io::Result<()> {
    use owo_colors::OwoColorize;

    let w = &mut writer;
    for category in aisle.categories.iter() {
        writeln!(
            w,
            "{}{}{}",
            '['.magenta(),
            category.name.green().bold(),
            ']'.magenta()
        )?;
        for igr in &category.ingredients {
            if !igr.names.is_empty() {
                let mut iter = igr.names.iter();
                write!(w, "  {}", iter.next().unwrap())?;
                for name in iter {
                    write!(w, "{} {name}", ','.magenta())?;
                }
                writeln!(w)?;
            }
        }
        writeln!(w)?;
    }

    Ok(())
}