add more types of text generator

src/main.rs

@@ -1,10 +1,12 @@
+extern crate markov;
 extern crate purrchance;
 extern crate serde;
 extern crate serenity;
 extern crate tokio;
 extern crate toml;
+// extern crate tracery;
 
-use purrchance::{Grammar, Purrchance, Symbol, parser::load_grammar};
+use purrchance::Purrchance;
 use serde::Deserialize;
 use serenity::{
     async_trait,
@@ -15,32 +17,64 @@ use std::fs::read_to_string;
 use std::sync::Arc;
 use std::time::Duration;
 
+enum TextGenerator {
+    Perchance { grammar: purrchance::Grammar, symbol: purrchance::Symbol },
+//    Tracery(tracery::Grammar),
+    Markov(markov::Chain<String>),
+}
+
+impl TextGenerator {
+    fn generate(&self) -> String {
+        match self {
+            TextGenerator::Perchance { grammar, symbol } => symbol.eval(&grammar).unwrap(),
+//            TextGenerator::Tracery(grammar) => grammar.flatten(),
+            TextGenerator::Markov(chain) => chain.generate_str(),
+        }
+    }
+}
+
 #[derive(Deserialize)]
-#[serde(rename_all = "lowercase")]
-enum GrammarType {
-    Perchance,
+#[serde(tag = "type", rename_all = "lowercase")]
+enum GeneratorSpec {
+    Perchance { path: String, symbol: String },
+//    Tracery { path: String, rule: String },
+    Markov { path: String, order: usize },
+}
+
+impl GeneratorSpec {
+    fn load(&self) -> TextGenerator {
+        match self {
+            GeneratorSpec::Perchance { path: p, symbol: s } => {
+                let grammar = purrchance::parser::load_grammar(&read_to_string(p).unwrap()).unwrap();
+                let symbol = purrchance::Symbol::NonTerminal(String::from(s));
+                TextGenerator::Perchance { grammar, symbol }
+            }
+/*
+            GeneratorSpec::Tracery { path, rule } => {
+                let mut grammar = tracery::from_json(read_to_string(path).unwrap()).unwrap();
+                grammar.default_rule(rule);
+                TextGenerator::Tracery(grammar)
+            }
+*/
+            GeneratorSpec::Markov { path, order } => {
+                let mut chain = markov::Chain::of_order(*order);
+                for line in read_to_string(path).unwrap().lines() {
+                    chain.feed_str(line);
+                }
+                TextGenerator::Markov(chain)
+            }
+        }
+    }
 }
 
 #[derive(Deserialize)]
 struct Config {
-    grammar_path: String,
-    grammar_type: GrammarType,
-    grammar_symbol: String,
+    generator: GeneratorSpec,
     token: String,
     channel_id: ChannelId,
     interval: u64,
 }
 
-struct TextGenerator {
-    grammar: Grammar,
-    symbol: Symbol,
-}
-
-impl TextGenerator {
-    pub fn generate(&self) -> String {
-        self.symbol.eval(&self.grammar).unwrap()
-    }
-}
 
 impl TypeMapKey for TextGenerator {
     type Value = TextGenerator;
@@ -118,24 +152,19 @@ impl EventHandler for Handler {
 async fn main() {
     let config: Config = toml::from_str(&read_to_string("config.toml").unwrap()).unwrap();
 
-    match config.grammar_type {
-        GrammarType::Perchance => {
-            let grammar = load_grammar(&read_to_string(config.grammar_path).unwrap()).unwrap();
-            let symbol = Symbol::NonTerminal(config.grammar_symbol);
+    let generator = config.generator.load();
 
-            let mut client = Client::new(&config.token)
-                .event_handler(Handler)
-                .await
-                .expect("err creating client");
+    let mut client = Client::new(&config.token)
+        .event_handler(Handler)
+        .await
+        .expect("err creating client");
 
-            {
-                let mut data = client.data.write().await;
-                data.insert::<TextGenerator>(TextGenerator { grammar, symbol });
-                data.insert::<Interval>(config.interval);
-                data.insert::<ChanId>(config.channel_id);
-                data.insert::<LoopStatus>(false);
-            }
-            client.start().await.unwrap();
-        }
+    {
+        let mut data = client.data.write().await;
+        data.insert::<TextGenerator>(generator);
+        data.insert::<Interval>(config.interval);
+        data.insert::<ChanId>(config.channel_id);
+        data.insert::<LoopStatus>(false);
     }
+    client.start().await.unwrap();
 }