tenebrous-dicebot/src/commands.rs

131 lines
3.5 KiB
Rust
Raw Normal View History

use crate::cofd::dice::DicePool;
use crate::dice::ElementExpression;
use crate::parser::trim;
2020-04-21 06:09:43 +00:00
use crate::roll::Roll;
pub mod parser;
2020-04-21 06:07:03 +00:00
pub struct Execution {
plain: String,
html: String,
}
2020-04-21 06:07:03 +00:00
impl Execution {
pub fn plain(&self) -> &str {
&self.plain
}
2020-04-21 06:07:03 +00:00
pub fn html(&self) -> &str {
&self.html
}
}
pub trait Command {
fn execute(&self) -> Execution;
fn name(&self) -> &'static str;
2020-04-21 06:07:03 +00:00
}
pub struct RollCommand(ElementExpression);
2020-04-21 06:07:03 +00:00
impl Command for RollCommand {
fn name(&self) -> &'static str {
"roll regular dice"
}
2020-04-21 06:07:03 +00:00
fn execute(&self) -> Execution {
let roll = self.0.roll();
let plain = format!("Dice: {}\nResult: {}", self.0, roll);
2020-04-21 06:09:43 +00:00
let html = format!(
2020-04-22 04:19:15 +00:00
"<p><strong>Dice:</strong> {}</p><p><strong>Result</strong>: {}</p>",
2020-04-21 06:09:43 +00:00
self.0, roll
);
Execution { plain, html }
}
}
pub struct PoolRollCommand(DicePool);
impl Command for PoolRollCommand {
fn name(&self) -> &'static str {
"roll dice pool"
}
fn execute(&self) -> Execution {
let roll = self.0.roll();
let plain = format!("Pool: {}\nResult: {}", self.0, roll);
let html = format!(
"<p><strong>Pool:</strong> {}</p><p><strong>Result</strong>: {}</p>",
self.0, roll
);
Execution { plain, html }
}
}
2020-04-22 04:19:15 +00:00
/// Parse a command string into a dynamic command execution trait object.
/// Returns an error if a command was recognized but not parsed correctly. Returns None if no
/// command was recognized.
pub fn parse_command(s: &str) -> Result<Option<Box<dyn Command>>, String> {
2020-04-21 06:07:03 +00:00
match parser::parse_command(s) {
Ok((input, command)) => match (input, &command) {
2020-08-28 00:13:01 +00:00
//This clause prevents bot from spamming messages to itself
//after executing a previous command.
("", Some(_)) | (_, None) => Ok(command),
//Any unconsumed input (except whitespace) is considered a parsing error.
(extra, _) => match trim(extra).as_str() {
"" => Ok(command),
_ => Err(format!("{}: malformed dice expression", s)),
},
},
Err(err) => Err(err.to_string()),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn chance_die_is_not_malformed() {
assert!(parse_command("!chance").is_ok());
}
#[test]
fn roll_malformed_expression_test() {
assert!(parse_command("!roll 1d20asdlfkj").is_err());
assert!(parse_command("!roll 1d20asdlfkj ").is_err());
}
#[test]
fn roll_dice_pool_malformed_expression_test() {
assert!(parse_command("!pool 8abc").is_err());
assert!(parse_command("!pool 8abc ").is_err());
}
#[test]
fn pool_whitespace_test() {
assert!(parse_command("!pool 8ns3 ")
.map(|p| p.is_some())
.expect("was error"));
assert!(parse_command(" !pool 8ns3")
.map(|p| p.is_some())
.expect("was error"));
assert!(parse_command(" !pool 8ns3 ")
.map(|p| p.is_some())
.expect("was error"));
}
#[test]
fn roll_whitespace_test() {
assert!(parse_command("!roll 1d4 + 5d6 -3 ")
.map(|p| p.is_some())
.expect("was error"));
assert!(parse_command("!roll 1d4 + 5d6 -3 ")
.map(|p| p.is_some())
.expect("was error"));
assert!(parse_command(" !roll 1d4 + 5d6 -3 ")
.map(|p| p.is_some())
.expect("was error"));
}
}