replique 0.3.0

A pure Rust dialogue system
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

//! Define the [`RepliqueHost`] trait for the Virtual Machine to execute
//! function on the host side without sending events.

use thiserror::Error;

use crate::dialogue::Value;

#[derive(Error, Debug)]
pub enum HostError {
    #[error("unknown function `{0}`")]
    UnknownFunction(String),
    #[error("`{name}`: `{message}`")]
    Failed { name: String, message: String },
    #[error("builtin `{name}`: `{message}`")]
    BuiltinFailed { name: String, message: String },
    #[error("subject {0} is unknown")]
    UnknownSubject(String),
    #[error("feature {0} is unknown")]
    UnknownFeature(String),
    #[error("feature {feature} is not on the subject {subject}")]
    FeatureNotOnSubject { feature: String, subject: String },
}

pub trait RepliqueHost {
    /// Call a function through the host. Function are instantaneous
    fn call(&mut self, name: &str, args: Vec<Value>) -> Result<Value, HostError>;

    /// Check if a subject has the given feature
    fn has_feature(&mut self, subject: &str, name: &str) -> Result<bool, HostError>;

    /// Value of the feature of a subject, as `Alice.Mana` reads it.
    fn feature(&mut self, subject: &str, name: &str) -> Result<Value, HostError>;
}

/// Default host, no additional function available.
/// Builtins are still available.
pub struct NoHost;

impl RepliqueHost for NoHost {
    fn call(&mut self, name: &str, _: Vec<Value>) -> Result<Value, HostError> {
        Err(HostError::UnknownFunction(name.into()))
    }

    fn has_feature(&mut self, _: &str, name: &str) -> Result<bool, HostError> {
        Err(HostError::UnknownFeature(name.into()))
    }

    fn feature(&mut self, _: &str, name: &str) -> Result<Value, HostError> {
        Err(HostError::UnknownFeature(name.into()))
    }
}

#[cfg(test)]
pub(crate) mod test {
    use super::*;

    /// A host with a handful of functions, which writes down every call it is
    /// given.
    ///
    /// The functions are the smallest set the tests need: one over a string,
    /// two over an int, and one that always fails.
    ///
    /// Alice and Bob are its subjects. Their moods are features with no value
    /// of their own; `mana` and `stats` are features only Alice has.
    #[derive(Default)]
    pub(crate) struct TestHost {
        /// Every call, in the order the VM made them, arguments already
        /// evaluated.
        pub calls: Vec<(String, Vec<Value>)>,
    }

    impl TestHost {
        /// Names of the functions called so far, for a test that only cares
        /// about which ones ran.
        pub fn called(&self) -> Vec<&str> {
            self.calls.iter().map(|(name, _)| name.as_str()).collect()
        }
    }

    impl RepliqueHost for TestHost {
        fn call(&mut self, name: &str, args: Vec<Value>) -> Result<Value, HostError> {
            self.calls.push((name.to_owned(), args.clone()));

            let failed = |message: &str| HostError::Failed {
                name: name.to_owned(),
                message: message.to_owned(),
            };

            match name {
                "upper_new" => match args.as_slice() {
                    [Value::String(text)] => Ok(Value::String(text.to_uppercase())),
                    _ => Err(failed("expected one string")),
                },
                "double" => match args.as_slice() {
                    [Value::Int(n)] => Ok(Value::Int(n * 2)),
                    _ => Err(failed("expected one int")),
                },
                "is_even" => match args.as_slice() {
                    [Value::Int(n)] => Ok(Value::Bool(n % 2 == 0)),
                    _ => Err(failed("expected one int")),
                },
                "boom" => Err(failed("this function always fails")),
                _ => Err(HostError::UnknownFunction(name.to_owned())),
            }
        }

        fn has_feature(&mut self, subject: &str, name: &str) -> Result<bool, HostError> {
            let supported_features = [
                "happy", "sad", "angry", "hungry", "thirsty", "mana", "stats",
            ];
            let alice_features = ["happy", "hungry", "mana", "stats"];
            let bob_features = ["sad", "hungry", "thirsty"];

            if !supported_features.contains(&name) {
                return Err(HostError::UnknownFeature(name.to_string()));
            }

            match subject {
                "Alice" => Ok(alice_features.contains(&name)),
                "Bob" => Ok(bob_features.contains(&name)),
                _ => Err(HostError::UnknownSubject(subject.to_string())),
            }
        }

        fn feature(&mut self, subject: &str, name: &str) -> Result<Value, HostError> {
            if !self.has_feature(subject, name)? {
                return Err(HostError::FeatureNotOnSubject {
                    feature: name.to_owned(),
                    subject: subject.to_owned(),
                });
            }

            Ok(match name {
                "mana" => Value::Int(12),
                "stats" => Value::Dict([("hp".to_owned(), Value::Int(7))].into_iter().collect()),
                // A mood holds nothing: having it is all there is to read.
                _ => Value::Bool(true),
            })
        }
    }
}