prosaic-core 1.0.1

General-purpose natural language generation from structured data
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

//! Tests for `Engine::language_preference` + `register_template_with_language`.

use prosaic_core::{Context, Engine, Salience, Session, Strictness, Value, Variation};
use prosaic_grammar_en::English;

#[test]
fn language_preference_picks_matching_variant() {
    let mut engine = Engine::new(English::new())
        .strictness(Strictness::Strict)
        .variation(Variation::Fixed)
        .language_preference("es");

    engine
        .register_template_with_language("greet", "Hello {name}", Some("en"))
        .unwrap();
    engine
        .register_template_with_language("greet", "Hola {name}", Some("es"))
        .unwrap();

    let mut ctx = Context::new();
    ctx.insert("name", Value::String("world".to_string()));

    let mut session = Session::new();
    let out = engine.render(&mut session, "greet", &ctx).unwrap();
    assert!(
        out.starts_with("Hola"),
        "expected Spanish variant; got: {out}"
    );
}

#[test]
fn language_preference_falls_back_to_unspecified() {
    let mut engine = Engine::new(English::new())
        .strictness(Strictness::Strict)
        .variation(Variation::Fixed)
        .language_preference("es");

    // Only an English variant registered.
    engine
        .register_template_with_language("greet", "Hello {name}", Some("en"))
        .unwrap();

    let mut ctx = Context::new();
    ctx.insert("name", Value::String("world".to_string()));

    let mut session = Session::new();
    let out = engine.render(&mut session, "greet", &ctx).unwrap();
    assert!(
        out.starts_with("Hello"),
        "expected fallback to English; got: {out}"
    );
}

#[test]
fn language_preference_falls_back_to_untagged() {
    let mut engine = Engine::new(English::new())
        .strictness(Strictness::Strict)
        .variation(Variation::Fixed)
        .language_preference("es");

    // No language-tagged variant; one untagged. Should pick the untagged.
    engine.register_template("greet", "Hello {name}").unwrap();

    let mut ctx = Context::new();
    ctx.insert("name", Value::String("world".to_string()));

    let mut session = Session::new();
    let out = engine.render(&mut session, "greet", &ctx).unwrap();
    assert!(out.starts_with("Hello"));
}

#[test]
fn no_preference_picks_among_all() {
    let mut engine = Engine::new(English::new())
        .strictness(Strictness::Strict)
        .variation(Variation::Fixed);
    // No language preference set.

    engine
        .register_template_with_language("greet", "Hello {name}", Some("en"))
        .unwrap();

    let mut ctx = Context::new();
    ctx.insert("name", Value::String("world".to_string()));

    let mut session = Session::new();
    let out = engine.render(&mut session, "greet", &ctx).unwrap();
    assert!(out.starts_with("Hello"));
}

#[test]
fn language_tagged_variant_with_salience() {
    let mut engine = Engine::new(English::new())
        .strictness(Strictness::Strict)
        .variation(Variation::Fixed)
        .language_preference("es");

    engine
        .register_template_with_language_at(
            "alert",
            "Brief alert for {name}",
            Salience::Low,
            Some("en"),
        )
        .unwrap();
    engine
        .register_template_with_language_at(
            "alert",
            "Alerta breve para {name}",
            Salience::Low,
            Some("es"),
        )
        .unwrap();

    let mut ctx = Context::new();
    ctx.insert("name", Value::String("Foo".to_string()));
    ctx.insert("salience", Value::String("low".to_string()));

    let mut session = Session::new();
    let out = engine.render(&mut session, "alert", &ctx).unwrap();
    assert!(out.starts_with("Alerta"), "got: {out}");
}