recipemd 0.2.0

Parser for the RecipeMD format
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

use std::{path::PathBuf, sync::LazyLock};

use miette::IntoDiagnostic;
use recipemd::Recipe;

static TESTCASE_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
    let testcase_dir = PathBuf::from("./recipemd/testcases/cases");
    assert!(
        testcase_dir.exists(),
        "repo must be cloned with --recurse-submodules"
    );
    testcase_dir
});

mod valid {
    use super::*;

    use pretty_assertions::assert_eq;

    macro_rules! testcase {
        ( $name:ident $( , ignore $( = $reason:literal )? )? ) => {
            #[test]
            $(
                #[ignore $( = $reason )? ]
            )?
            fn $name() -> miette::Result<()> {
                valid(stringify!($name))
            }
        };
    }

    fn valid(name: &str) -> miette::Result<()> {
        let md_path = TESTCASE_DIR.join(format!("{name}.md"));
        let json_path = TESTCASE_DIR.join(format!("{name}.json"));

        let md = std::fs::read_to_string(&md_path).into_diagnostic()?;
        let json = std::fs::read_to_string(&json_path).into_diagnostic()?;

        let ours = Recipe::parse(&md)?;
        let reference: Recipe = serde_json::from_str(&json).into_diagnostic()?;

        assert_eq!(ours, reference, "recipes don't match (ours vs. reference)");

        Ok(())
    }

    testcase!(commonmark_fenced_code_blocks);
    testcase!(commonmark_reference_images);
    testcase!(commonmark_reference_links);
    testcase!(ingredients_groups);
    testcase!(
        ingredients_links,
        ignore = "unspecified: differences in parsing whitespace"
    );
    testcase!(
        ingredients_multiline,
        ignore = "unspecified: differences in parsing whitespace"
    );
    testcase!(ingredients_numbered);
    testcase!(ingredients_sublist);
    testcase!(ingredients);
    testcase!(instructions);
    testcase!(recipe);
    testcase!(tags_no_partial);
    testcase!(tags_splitting);
    testcase!(tags_yields);
    testcase!(tags);
    testcase!(title_setext);
    testcase!(title);
    testcase!(yields_tags);
    testcase!(yields);
}

mod invalid {
    use miette::Context;
    use recipemd::ErrorKind;

    use super::*;

    macro_rules! testcase {
        ( $name:ident, $error_kind:expr $( , ignore $( = $reason:literal )? )? ) => {
            #[test]
            $(
                #[ignore $( = $reason )? ]
            )?
            fn $name() -> miette::Result<()> {
                invalid(stringify!($name), $error_kind)
            }
        };
    }

    fn invalid(name: &str, error_kind: ErrorKind) -> miette::Result<()> {
        let md = std::fs::read_to_string(TESTCASE_DIR.join(format!("{name}.invalid.md")))
            .into_diagnostic()?;

        match Recipe::parse(&md) {
            Ok(recipe) => Err(miette::miette!(
                "recipe is invalid but no error was generated\n{recipe:#?}"
            )),
            Err(e) => {
                if e.kind == error_kind {
                    Ok(())
                } else {
                    Err(e).wrap_err(format!(
                        "Expected error \"{error_kind}\" but got different error",
                    ))
                }
            }
        }
    }

    testcase!(empty, ErrorKind::ExpectedTitle);
    testcase!(ingredients_empty, ErrorKind::EmptyIngredient);
    testcase!(ingredients_no_divider, ErrorKind::ExpectedHorizontalLine);
    testcase!(ingredients_no_name, ErrorKind::EmptyIngredient);
    testcase!(instructions_no_divider, ErrorKind::ExpectedHorizontalLine);
    testcase!(tags_multiple, ErrorKind::MultipleTagsSections);
    testcase!(title_second_level_heading, ErrorKind::ExpectedTitle);
    testcase!(yields_multiple, ErrorKind::MultipleYieldsSections);
}