foldr 0.2.2

Foldr, the blazing fast templating tool
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

use crate::templates::Template;
use clap::Args;
use itertools::Itertools;

use super::command::RunCommand;

#[derive(Args, Debug)]
pub struct ListCommand {
    #[arg(help = "An optional grep style pattern used to filter the list output")]
    pattern: Option<String>,
    #[arg(
        short,
        long,
        help = "Instead of grouping by template, flatten each version of the same template into seperate entries"
    )]
    flatten: bool,
}

impl RunCommand for ListCommand {
    fn run(&self, config: crate::config::Config) -> Result<(), super::command::CommandError> {
        let mut templates = Template::get_existing(&config)?;
        if templates.len() == 0 {
            println!("No templates stored yet. Create a new one using foldr save");
            return Ok(());
        }
        let longest_template_name = templates
            .iter()
            .max_by_key(|t| t.info.name.chars().count())
            .unwrap()
            .info
            .name
            .chars()
            .count()
            .clamp(20, usize::MAX);
        println!(
            "{:<width$}{:<3}",
            "name",
            "version",
            width = longest_template_name,
        );
        println!("{}", "-".repeat(longest_template_name + 3));
        if let Some(pattern) = &self.pattern {
            templates = templates
                .iter()
                .filter(|i| i.info.name.contains(pattern))
                .map(|t| t.clone())
                .collect();
        }
        templates.sort_by_key(|i| i.info.iteration);
        templates.sort_by_key(|i| i.info.name.clone());
        if self.flatten {
            for template in templates {
                println!(
                    "{:<width$}{:<3}",
                    template.info.name,
                    template.info.iteration,
                    width = longest_template_name
                );
            }
        } else {
            for (key, group) in &templates.iter().chunk_by(|t| &t.info.name) {
                println!(
                    "{:<width$}{:<3}",
                    key.to_string(),
                    group
                        .collect::<Vec<&Template>>()
                        .iter()
                        .map(|t| t.info.iteration)
                        .last()
                        .unwrap(),
                    width = longest_template_name
                );
            }
        }

        return Ok(());
    }
}