quocktail 0.1.6

Rust CLI for searching through nested directories of markdown files with frontmatter, filtering and displaying the results
Documentation 
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

use owo_colors::OwoColorize;
use yaml_rust::Yaml;
use std::fmt;

use crate::color::Styles;
use crate::parse::{Recipe, YAML_OR_KEY};

impl Recipe {
    /// Returns a type that can display `MyValue`.
    pub fn display(&self) -> RecipeDisplay {
        RecipeDisplay {
            recipe: self,
            styles: Box::default(),
        }
    }
}

/// Displayer for [`Recipe`].
pub struct RecipeDisplay<'a> {
    recipe: &'a Recipe,
    styles: Box<Styles>,
}

impl<'a> RecipeDisplay<'a> {
    /// Colorizes the output.
    pub fn colorize(&mut self) {
        self.styles.colorize();
    }
}

impl<'a> fmt::Display for RecipeDisplay<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Recipe {}\n\n",
            self.recipe.name().style(self.styles.title_style),
        )?;

        for (k, v) in self.recipe.ingredients().hash.iter() {
            let k = k.as_str().unwrap_or("");
            match v {
                Yaml::Real(_) => todo!(""),
                Yaml::Integer(_) => todo!(),
                Yaml::String(v) => writeln!(
                    f,
                    "{}: {}",
                    k.style(self.styles.key_style),
                    v.style(self.styles.value_style)
                )?,
                Yaml::Boolean(_) => todo!(),
                Yaml::Array(arr) => {
                    writeln!(
                        f,
                        "{}:",
                        k.style(self.styles.key_style),
                    )?;
                    for v in arr {
                        writeln!(
                            f,
                            "  - {}",
                            v.as_str().unwrap_or_default().style(self.styles.value_style),
                        )?;
                    }
                },
                Yaml::Hash(hash) => {
                    if let Some(Yaml::Array(or_arr)) = hash.get(&YAML_OR_KEY) {
                        writeln!(
                            f,
                            "{} (choice of):",
                            k.style(self.styles.key_style),
                        )?;
                        for v in or_arr {
                            writeln!(
                                f,
                                "  - {}",
                                v.as_str().unwrap_or_default().style(self.styles.value_style),
                            )?;
                        }
                    } else {
                        writeln!(
                            f,
                            "unexpected format {}: {:?}",
                            k.style(self.styles.key_style),
                            v
                        )?;
                    }
                },
                Yaml::Alias(_) => todo!(),
                Yaml::Null => {},
                Yaml::BadValue => todo!(),
            };
        }

        write!(
            f,
            "{}\n\n",
            self.recipe.instructions().style(self.styles.body_style),
        )
    }
}