cook-markdown 0.0.2

A CookLang to Markdown transpiling library.
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::ops::Not;
use cook_with_rust_parser::*;


pub fn recipe_to_markdown(recipe: &Recipe) -> String {
    let mut ingredient_specifier_iter = recipe.metadata.ingredients_specifiers.iter();
    let mut cookware_iter = recipe.metadata.cookware.iter();
    let mut timer_iter = recipe.metadata.timer.iter();
    let mut result_string = String::new();

    if recipe.metadata.ingredients.is_empty().not() {
        result_string += "### Ingredients\n";
        result_string += "| Ingredient | Amount | Unit |\n";
        result_string += "|------------|--------|------|\n";

        let ingredients = recipe.metadata.ingredients.values();
        ingredients.for_each(|e| {
            let amount = match &e.amount {
                Some(d) => {
                    match d {
                        Amount::Multi(dd) => {
                            format!("servings * {}", dd)
                        }
                        Amount::Servings(dd) => {
                            let mut servings = String::new();
                            dd.iter().for_each(|a| {
                                servings.push_str(&a.to_string());
                                servings.push('|');
                            });
                            servings.pop();
                            servings
                        }
                        Amount::Single(dd) => {
                            dd.to_string()
                        }
                    }
                },
                None => "-".to_string(),
            };
            let unit = match &e.unit {
                None => "-".to_string(),
                Some(u) => u.to_string(),
            };
            let line = format!("| {} | {} | {} |\n", e.name, amount, unit);
            result_string += &line;
        });
        result_string += "\n"
    }

    if recipe.metadata.cookware.is_empty().not() {
        result_string += "\n### Cookware:\n";
        recipe.metadata.cookware.iter().for_each(|cookw| {
            result_string += format!("* {}\n", cookw).as_str();
        });
    }

    recipe.instruction.chars().for_each(|char| {
        if char == '@' {
            let insert_ingredient = ingredient_specifier_iter.next().unwrap();
            let ingredient_referenced = recipe.metadata.ingredients.get(&insert_ingredient.ingredient).unwrap();
            let ingredient_name = &ingredient_referenced.name;
            let ingredient_unit = match &ingredient_referenced.unit {
                None => "".to_string(),
                Some(d) => {
                    let mut res = String::from(' ');
                    res.push_str(d.as_str());
                    res
                },
            };
            let ingredient_amount = match &insert_ingredient.amount_in_step {
                Amount::Multi(d) => {
                    format!(" *{}", d)
                }
                Amount::Servings(dd) => {
                    let mut servings = String::new();
                    servings.push(' ');
                    dd.iter().for_each(|a| {
                        servings.push_str(&a.to_string());
                        servings.push('|');
                    });
                    servings.pop();
                    // servings.push(' ');
                    servings
                }
                Amount::Single(d) => {
                    let mut res = String::from(' ');
                    res.push_str(d.to_string().as_str());
                    // res.push(' ');
                    res
                }
            };
            let insert_string = format!("__{}{}{}__", ingredient_name, ingredient_amount, ingredient_unit);
            result_string += &insert_string;
        } else if char == '#' {
            result_string.push_str("_");
            result_string.push_str(cookware_iter.next().unwrap());
            result_string.push_str("_");
        } else if char == '~' {
            let timer = timer_iter.next().unwrap();
            result_string.push_str("__");
            result_string.push_str(&timer.amount.to_string());
            result_string.push(' ');
            result_string.push_str(&timer.unit);
            result_string.push_str("__");
        } else {
            result_string.push(char);
        }
    });

    result_string
}

#[cfg(test)]
mod tests {
    use std::fs::read_to_string;
    use cook_with_rust_parser::parse;
    use crate::recipe_to_markdown;

    #[test]
    fn it_works() {
        let inp = read_to_string("../spec/examples/Coffee Souffle.cook").unwrap();
        let recipe = parse(&inp).unwrap();

        let _result = recipe_to_markdown(&recipe);

        // std::fs::write("TEST.md", result);
    }
}