cooklang 0.18.6

Cooklang parser with opt-in extensions
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use indoc::indoc;

#[test]
fn test_invalid_yaml_frontmatter_becomes_warning() {
    let input = indoc! {r#"
        ---
        title: Test Recipe
        tags: [test
        invalid yaml here
        ---
        
        This is a test recipe with invalid YAML frontmatter.
        
        @eggs{2} and @butter{1%tbsp}
    "#};

    let result = cooklang::parse(input);

    // Should not fail to parse
    assert!(
        result.output().is_some(),
        "Recipe should parse successfully despite invalid YAML"
    );

    let recipe = result.output().unwrap();
    let warnings = result.report();

    // Should have warnings about invalid YAML
    assert!(
        !warnings.is_empty(),
        "Should have warnings about invalid YAML"
    );

    // The frontmatter should be ignored, so metadata should be empty
    assert!(
        recipe.metadata.map.is_empty(),
        "Metadata should be empty when YAML is invalid"
    );

    // Should still parse the recipe content
    assert_eq!(
        recipe.ingredients.len(),
        2,
        "Should still parse ingredients"
    );
    assert_eq!(recipe.ingredients[0].name, "eggs");
    assert_eq!(recipe.ingredients[1].name, "butter");
}

#[test]
fn test_valid_yaml_frontmatter_still_works() {
    let input = indoc! {r#"
        ---
        title: Test Recipe
        tags: [test, recipe]
        prep_time: 10 min
        ---
        
        This is a test recipe with valid YAML frontmatter.
        
        @eggs{2} and @butter{1%tbsp}
    "#};

    let result = cooklang::parse(input);

    // Should parse successfully
    assert!(
        result.output().is_some(),
        "Recipe should parse successfully"
    );

    let recipe = result.output().unwrap();

    // Metadata should be parsed
    assert!(
        !recipe.metadata.map.is_empty(),
        "Metadata should not be empty"
    );
    assert_eq!(
        recipe.metadata.map.get("title").and_then(|v| v.as_str()),
        Some("Test Recipe"),
        "Title should be parsed correctly"
    );

    // Should still parse the recipe content
    assert_eq!(recipe.ingredients.len(), 2, "Should parse ingredients");
    assert_eq!(recipe.ingredients[0].name, "eggs");
    assert_eq!(recipe.ingredients[1].name, "butter");
}

#[test]
fn test_invalid_yaml_with_colon_in_value() {
    let input = indoc! {r#"
        ---
        title: Recipe: with colon
        description: This has: many: colons
        tags: [unclosed
        ---
        
        @flour{2%cups}
    "#};

    let result = cooklang::parse(input);

    // Should not fail to parse
    assert!(
        result.output().is_some(),
        "Recipe should parse successfully despite invalid YAML"
    );

    let recipe = result.output().unwrap();
    let warnings = result.report();

    // Should have warnings
    assert!(
        !warnings.is_empty(),
        "Should have warnings about invalid YAML"
    );

    // Metadata should be empty due to invalid YAML
    assert!(
        recipe.metadata.map.is_empty(),
        "Metadata should be empty when YAML is invalid"
    );

    // Should still parse ingredients
    assert_eq!(recipe.ingredients.len(), 1);
    assert_eq!(recipe.ingredients[0].name, "flour");
}

#[test]
fn test_completely_malformed_yaml() {
    let input = indoc! {r#"
        ---
        { this is not valid yaml at all }}}
        : : : :
        ---
        
        Simple recipe with @salt and @pepper
    "#};

    let result = cooklang::parse(input);

    // Should not fail to parse
    assert!(
        result.output().is_some(),
        "Recipe should parse successfully despite malformed YAML"
    );

    let recipe = result.output().unwrap();
    let warnings = result.report();

    // Should have warnings
    assert!(
        !warnings.is_empty(),
        "Should have warnings about invalid YAML"
    );

    // Should contain information about invalid YAML in warning
    let warning_str = format!("{warnings:?}");
    assert!(
        warning_str.contains("Invalid YAML") || warning_str.contains("invalid YAML"),
        "Warning should mention invalid YAML"
    );

    // Metadata should be empty
    assert!(
        recipe.metadata.map.is_empty(),
        "Metadata should be empty when YAML is invalid"
    );

    // Should still parse the recipe
    assert_eq!(recipe.ingredients.len(), 2);
    assert_eq!(recipe.ingredients[0].name, "salt");
    assert_eq!(recipe.ingredients[1].name, "pepper");
}