Compare commits
No commits in common. "master" and "keep_drop_function" have entirely different histories.
master
...
keep_drop_
|
|
@ -3,7 +3,7 @@ name: build-and-test
|
|||
|
||||
steps:
|
||||
- name: test
|
||||
image: rust:1.80
|
||||
image: rust:1.51
|
||||
commands:
|
||||
- apt-get update
|
||||
- apt-get install -y cmake
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
14
Dockerfile
14
Dockerfile
|
|
@ -1,15 +1,16 @@
|
|||
# Builder image with development dependencies.
|
||||
FROM ghcr.io/void-linux/void-linux:latest-mini-x86_64 as builder
|
||||
RUN xbps-install -S
|
||||
RUN xbps-install -yu xbps
|
||||
FROM bougyman/voidlinux:glibc as builder
|
||||
RUN xbps-install -Syu
|
||||
RUN xbps-install -Sy base-devel rustup cmake wget gnupg
|
||||
RUN xbps-install -Sy base-devel rustup cargo cmake wget gnupg
|
||||
RUN xbps-install -Sy openssl-devel libstdc++-devel
|
||||
RUN rustup-init -qy
|
||||
|
||||
# Install tini for signal processing and zombie killing
|
||||
ENV TINI_VERSION v0.19.0
|
||||
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini /usr/local/bin/tini
|
||||
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini.asc /tini.asc
|
||||
RUN gpg --batch --keyserver hkp://keyserver.ubuntu.com --recv-keys 595E85A6B1B4779EA4DAAEC70B588DFF0527A9B7 \
|
||||
&& gpg --batch --verify /tini.asc /usr/local/bin/tini
|
||||
RUN chmod +x /usr/local/bin/tini
|
||||
|
||||
# Build dicebot
|
||||
|
|
@ -19,10 +20,7 @@ ADD . ./
|
|||
RUN . /root/.cargo/env && cargo build --release
|
||||
|
||||
# Final image
|
||||
FROM ghcr.io/void-linux/void-linux:latest-mini-x86_64
|
||||
RUN xbps-install -S
|
||||
RUN xbps-install -yu xbps
|
||||
RUN xbps-install -Syu
|
||||
FROM bougyman/voidlinux:tiny
|
||||
RUN xbps-install -Sy ca-certificates libstdc++
|
||||
COPY --from=builder \
|
||||
/root/src/target/release/dicebot \
|
||||
|
|
|
|||
|
|
@ -278,7 +278,6 @@ The most basic plans are:
|
|||
* Perhaps some sort of character sheet integration. But for that, we
|
||||
would need a sheet service.
|
||||
* Use environment variables instead of config file in Docker image.
|
||||
* Per-system game rules.
|
||||
|
||||
## Credits
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
[package]
|
||||
name = "tenebrous-dicebot"
|
||||
version = "0.13.2"
|
||||
rust-version = "1.68"
|
||||
version = "0.13.1"
|
||||
authors = ["projectmoon <projectmoon@agnos.is>", "Taylor C. Richberger <taywee@gmx.com>"]
|
||||
edition = "2018"
|
||||
license = 'AGPL-3.0-or-later'
|
||||
|
|
@ -16,7 +15,7 @@ tonic-build = "0.4"
|
|||
|
||||
[dependencies]
|
||||
# indexmap version locked fixes a dependency cycle.
|
||||
# indexmap = "=1.6.2"
|
||||
indexmap = "=1.6.2"
|
||||
log = "0.4"
|
||||
tracing-subscriber = "0.2"
|
||||
toml = "0.5"
|
||||
|
|
@ -33,10 +32,9 @@ combine = "4.5"
|
|||
futures = "0.3"
|
||||
html2text = "0.2"
|
||||
phf = { version = "0.8", features = ["macros"] }
|
||||
matrix-sdk = { version = "0.6" }
|
||||
refinery = { version = "0.8", features = ["rusqlite"]}
|
||||
barrel = { version = "0.7", features = ["sqlite3"] }
|
||||
strum = { version = "0.22", features = ["derive"] }
|
||||
matrix-sdk = { version = "0.3" }
|
||||
refinery = { version = "0.6", features = ["rusqlite"]}
|
||||
barrel = { version = "0.6", features = ["sqlite3"] }
|
||||
tempfile = "3"
|
||||
substring = "1.4"
|
||||
fuse-rust = "0.2"
|
||||
|
|
@ -45,7 +43,7 @@ prost = "0.7"
|
|||
tenebrous-rpc = { path = "../rpc", version = "0.1.0" }
|
||||
|
||||
[dependencies.sqlx]
|
||||
version = "0.6"
|
||||
version = "0.5"
|
||||
features = [ "offline", "sqlite", "runtime-tokio-native-tls" ]
|
||||
|
||||
[dependencies.serde]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,35 @@
|
|||
# Builder image with development dependencies.
|
||||
FROM bougyman/voidlinux:glibc as builder
|
||||
RUN xbps-install -Syu
|
||||
RUN xbps-install -Sy base-devel rustup cargo cmake wget gnupg
|
||||
RUN xbps-install -Sy openssl-devel libstdc++-devel
|
||||
RUN rustup-init -qy
|
||||
RUN rustup component add rustfmt # Needed for protobuf building.
|
||||
|
||||
# Install tini for signal processing and zombie killing
|
||||
ENV TINI_VERSION v0.19.0
|
||||
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini /usr/local/bin/tini
|
||||
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini.asc /tini.asc
|
||||
RUN gpg --batch --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 595E85A6B1B4779EA4DAAEC70B588DFF0527A9B7 \
|
||||
&& gpg --batch --verify /tini.asc /usr/local/bin/tini
|
||||
RUN chmod +x /usr/local/bin/tini
|
||||
|
||||
# Build dicebot
|
||||
RUN mkdir -p /root/src
|
||||
WORKDIR /root/src
|
||||
ADD . ./
|
||||
RUN . /root/.cargo/env && cargo build --release
|
||||
|
||||
# Final image
|
||||
FROM bougyman/voidlinux:tiny
|
||||
RUN xbps-install -Sy ca-certificates libstdc++
|
||||
COPY --from=builder \
|
||||
/root/src/target/release/dicebot \
|
||||
/usr/local/bin/
|
||||
COPY --from=builder \
|
||||
/usr/local/bin/tini \
|
||||
/usr/local/bin/
|
||||
|
||||
ENV XDG_CACHE_HOME "/cache"
|
||||
ENV DATABASE_PATH "/cache/bot-db"
|
||||
ENTRYPOINT [ "/usr/local/bin/tini", "-v", "--", "/usr/local/bin/dicebot", "/config/dicebot-config.toml" ]
|
||||
|
|
@ -6,9 +6,8 @@
|
|||
use std::fmt;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
/// A basic dice roll, in XdY notation, like "1d4" or "3d6".
|
||||
/// Optionally supports D&D advantage/disadvantge keep-or-drop
|
||||
/// functionality.
|
||||
//Old stuff, for regular dice rolling. To be moved elsewhere.
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
||||
pub struct Dice {
|
||||
pub(crate) count: u32,
|
||||
|
|
@ -16,42 +15,26 @@ pub struct Dice {
|
|||
pub(crate) keep_drop: KeepOrDrop,
|
||||
}
|
||||
|
||||
/// Enum indicating how to handle bonuses or penalties using extra
|
||||
/// dice. If set to Keep, the roll will keep the highest X number of
|
||||
/// dice in the roll, and add those together. If set to Drop, the
|
||||
/// opposite is performed, and the lowest X number of dice are added
|
||||
/// instead. If set to None, then all dice in the roll are added up as
|
||||
/// normal.
|
||||
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
||||
pub enum KeepOrDrop {
|
||||
/// Keep only the X highest dice for adding up to the total.
|
||||
Keep(u32),
|
||||
|
||||
/// Keep only the X lowest dice (i.e. drop the highest) for adding
|
||||
/// up to the total.
|
||||
Drop(u32),
|
||||
|
||||
/// Add up all dice in the roll for the total.
|
||||
None,
|
||||
}
|
||||
|
||||
impl fmt::Display for Dice {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self.keep_drop {
|
||||
KeepOrDrop::Keep(keep) => write!(f, "{}d{}k{}", self.count, self.sides, keep),
|
||||
KeepOrDrop::Drop(drop) => write!(f, "{}d{}dh{}", self.count, self.sides, drop),
|
||||
KeepOrDrop::None => write!(f, "{}d{}", self.count, self.sides),
|
||||
KeepOrDrop::None => write!(f, "{}d{}", self.count, self.sides),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
||||
pub enum KeepOrDrop {
|
||||
Keep (u32),
|
||||
Drop (u32),
|
||||
None,
|
||||
}
|
||||
|
||||
impl Dice {
|
||||
pub fn new(count: u32, sides: u32, keep_drop: KeepOrDrop) -> Dice {
|
||||
Dice {
|
||||
count,
|
||||
sides,
|
||||
keep_drop,
|
||||
}
|
||||
Dice { count, sides, keep_drop }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,8 +4,6 @@
|
|||
* project.
|
||||
*/
|
||||
use nom::bytes::complete::take_while;
|
||||
use nom::error::ErrorKind as NomErrorKind;
|
||||
use nom::Err as NomErr;
|
||||
use nom::{
|
||||
alt, bytes::complete::tag, character::complete::digit1, complete, many0, named,
|
||||
sequence::tuple, tag, IResult,
|
||||
|
|
@ -33,74 +31,54 @@ enum Sign {
|
|||
Minus,
|
||||
}
|
||||
|
||||
/// Intermediate parsed value for a keep-drop expression to indicate
|
||||
/// which one it is.
|
||||
enum ParsedKeepOrDrop<'a> {
|
||||
Keep(&'a str),
|
||||
Drop(&'a str),
|
||||
NotPresent,
|
||||
}
|
||||
|
||||
macro_rules! too_big {
|
||||
($input: expr) => {
|
||||
NomErr::Error(($input, NomErrorKind::TooLarge))
|
||||
};
|
||||
}
|
||||
|
||||
/// Parse a dice expression. Does not eat whitespace
|
||||
fn parse_dice(input: &str) -> IResult<&str, Dice> {
|
||||
// parse main dice expression
|
||||
let (input, (count, _, sides)) = tuple((digit1, tag("d"), digit1))(input)?;
|
||||
let count: u32 = count.parse().map_err(|_| too_big!(count))?;
|
||||
let sides = sides.parse().map_err(|_| too_big!(sides))?;
|
||||
let (input, keep_drop) = parse_keep_or_drop(input, count)?;
|
||||
Ok((input, Dice::new(count, sides, keep_drop)))
|
||||
}
|
||||
|
||||
/// Extract keep/drop number as a string. Fails if the value is not a
|
||||
/// string.
|
||||
fn parse_keep_or_drop_text<'a>(
|
||||
symbol: &'a str,
|
||||
input: &'a str,
|
||||
) -> IResult<&'a str, ParsedKeepOrDrop<'a>> {
|
||||
let (parsed_kd, input) = match tuple::<&str, _, (_, _), _>((tag(symbol), digit1))(input) {
|
||||
// if ok, one of the expressions is present
|
||||
Ok((rest, (_, kd_expr))) => match symbol {
|
||||
"k" => (ParsedKeepOrDrop::Keep(kd_expr), rest),
|
||||
"dh" => (ParsedKeepOrDrop::Drop(kd_expr), rest),
|
||||
_ => panic!("Unrecogized keep-drop symbol: {}", symbol),
|
||||
},
|
||||
// otherwise absent (attempt to keep all dice)
|
||||
Err(_) => (ParsedKeepOrDrop::NotPresent, input),
|
||||
// check for keep expression to keep highest dice (2d20k1)
|
||||
let (keep, input) = match tuple::<&str, _, (_, _), _>((tag("k"), digit1))(input) {
|
||||
// if ok, keep expression is present
|
||||
Ok((rest, (_, keep_amount))) => (keep_amount, rest),
|
||||
// otherwise absent and keep all dice
|
||||
Err(_) => ("", input)
|
||||
};
|
||||
|
||||
Ok((input, parsed_kd))
|
||||
}
|
||||
// check for drop expression to drop highest dice (2d20dh1)
|
||||
let (drop, input) = match tuple::<&str, _, (_, _), _>((tag("dh"), digit1))(input) {
|
||||
// if ok, keep expression is present
|
||||
Ok((rest, (_, drop_amount))) => (drop_amount, rest),
|
||||
// otherwise absent and keep all dice
|
||||
Err(_) => ("", input)
|
||||
};
|
||||
|
||||
/// Parse keep/drop expression, which consits of "k" or "dh" following
|
||||
/// a dice expression. For example, "1d4h3" or "1d4dh2".
|
||||
fn parse_keep_or_drop<'a>(input: &'a str, count: u32) -> IResult<&'a str, KeepOrDrop> {
|
||||
let (input, keep) = parse_keep_or_drop_text("k", input)?;
|
||||
let (input, drop) = parse_keep_or_drop_text("dh", input)?;
|
||||
let count: u32 = count.parse().unwrap();
|
||||
|
||||
use ParsedKeepOrDrop::*;
|
||||
let keep_drop: KeepOrDrop = match (keep, drop) {
|
||||
//Potential valid Keep expression.
|
||||
(Keep(keep), NotPresent) => match keep.parse().map_err(|_| too_big!(input))? {
|
||||
_i if _i > count || _i == 0 => Ok(KeepOrDrop::None),
|
||||
i => Ok(KeepOrDrop::Keep(i)),
|
||||
// don't allow keep greater than number of dice, and don't allow keep zero
|
||||
let keep_drop = match keep.parse::<u32>() {
|
||||
// Ok, there's a keep value, check and create Keep
|
||||
Ok(i) => match i {
|
||||
_i if _i > count || _i == 0 => KeepOrDrop::None,
|
||||
i => KeepOrDrop::Keep(i),
|
||||
},
|
||||
//Potential valid Drop expression.
|
||||
(NotPresent, Drop(drop)) => match drop.parse().map_err(|_| too_big!(input))? {
|
||||
_i if _i >= count => Ok(KeepOrDrop::None),
|
||||
i => Ok(KeepOrDrop::Drop(i)),
|
||||
// Err, check if drop works
|
||||
Err(_) => {
|
||||
match drop.parse::<u32>() {
|
||||
// Ok, there's a drop value, check and create Drop
|
||||
Ok(i) => match i {
|
||||
_i if i >= count => KeepOrDrop::None,
|
||||
i => KeepOrDrop::Drop(i),
|
||||
},
|
||||
// Err, there's neither keep nor drop
|
||||
Err(_) => KeepOrDrop::None,
|
||||
}
|
||||
},
|
||||
//No Keep or Drop specified; regular behavior.
|
||||
(NotPresent, NotPresent) => Ok(KeepOrDrop::None),
|
||||
//Anything else is an error.
|
||||
_ => Err(NomErr::Error((input, NomErrorKind::Many1))),
|
||||
}?;
|
||||
};
|
||||
|
||||
Ok((input, keep_drop))
|
||||
Ok((
|
||||
input,
|
||||
Dice::new(count, sides.parse().unwrap(), keep_drop),
|
||||
))
|
||||
}
|
||||
|
||||
// Parse a single digit expression. Does not eat whitespace
|
||||
|
|
@ -171,92 +149,18 @@ mod tests {
|
|||
use super::*;
|
||||
#[test]
|
||||
fn dice_test() {
|
||||
assert_eq!(
|
||||
parse_dice("2d4"),
|
||||
Ok(("", Dice::new(2, 4, KeepOrDrop::None)))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("20d40"),
|
||||
Ok(("", Dice::new(20, 40, KeepOrDrop::None)))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("8d7"),
|
||||
Ok(("", Dice::new(8, 7, KeepOrDrop::None)))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("2d20k1"),
|
||||
Ok(("", Dice::new(2, 20, KeepOrDrop::Keep(1))))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("100d10k90"),
|
||||
Ok(("", Dice::new(100, 10, KeepOrDrop::Keep(90))))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("11d10k10"),
|
||||
Ok(("", Dice::new(11, 10, KeepOrDrop::Keep(10))))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("12d10k11"),
|
||||
Ok(("", Dice::new(12, 10, KeepOrDrop::Keep(11))))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("12d10k13"),
|
||||
Ok(("", Dice::new(12, 10, KeepOrDrop::None)))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("12d10k0"),
|
||||
Ok(("", Dice::new(12, 10, KeepOrDrop::None)))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("20d40dh5"),
|
||||
Ok(("", Dice::new(20, 40, KeepOrDrop::Drop(5))))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("8d7dh9"),
|
||||
Ok(("", Dice::new(8, 7, KeepOrDrop::None)))
|
||||
);
|
||||
assert_eq!(
|
||||
parse_dice("8d7dh8"),
|
||||
Ok(("", Dice::new(8, 7, KeepOrDrop::None)))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cant_have_both_keep_and_drop_test() {
|
||||
let res = parse_dice("1d4k3dh2");
|
||||
assert!(res.is_err());
|
||||
match res {
|
||||
Err(NomErr::Error((_, kind))) => {
|
||||
assert_eq!(kind, NomErrorKind::Many1);
|
||||
}
|
||||
_ => panic!("Got success, expected error"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn big_number_of_dice_doesnt_crash_test() {
|
||||
let res = parse_dice("64378631476346123874527551481376547657868536d4");
|
||||
assert!(res.is_err());
|
||||
match res {
|
||||
Err(NomErr::Error((input, kind))) => {
|
||||
assert_eq!(kind, NomErrorKind::TooLarge);
|
||||
assert_eq!(input, "64378631476346123874527551481376547657868536");
|
||||
}
|
||||
_ => panic!("Got success, expected error"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn big_number_of_sides_doesnt_crash_test() {
|
||||
let res = parse_dice("1d423562312587425472658956278456298376234876");
|
||||
assert!(res.is_err());
|
||||
match res {
|
||||
Err(NomErr::Error((input, kind))) => {
|
||||
assert_eq!(kind, NomErrorKind::TooLarge);
|
||||
assert_eq!(input, "423562312587425472658956278456298376234876");
|
||||
}
|
||||
_ => panic!("Got success, expected error"),
|
||||
}
|
||||
assert_eq!(parse_dice("2d4"), Ok(("", Dice::new(2, 4, KeepOrDrop::None))));
|
||||
assert_eq!(parse_dice("20d40"), Ok(("", Dice::new(20, 40, KeepOrDrop::None))));
|
||||
assert_eq!(parse_dice("8d7"), Ok(("", Dice::new(8, 7, KeepOrDrop::None))));
|
||||
assert_eq!(parse_dice("2d20k1"), Ok(("", Dice::new(2, 20, KeepOrDrop::Keep(1)))));
|
||||
assert_eq!(parse_dice("100d10k90"), Ok(("", Dice::new(100, 10, KeepOrDrop::Keep(90)))));
|
||||
assert_eq!(parse_dice("11d10k10"), Ok(("", Dice::new(11, 10, KeepOrDrop::Keep(10)))));
|
||||
assert_eq!(parse_dice("12d10k11"), Ok(("", Dice::new(12, 10, KeepOrDrop::Keep(11)))));
|
||||
assert_eq!(parse_dice("12d10k13"), Ok(("", Dice::new(12, 10, KeepOrDrop::None))));
|
||||
assert_eq!(parse_dice("12d10k0"), Ok(("", Dice::new(12, 10, KeepOrDrop::None))));
|
||||
assert_eq!(parse_dice("20d40dh5"), Ok(("", Dice::new(20, 40, KeepOrDrop::Drop(5)))));
|
||||
assert_eq!(parse_dice("8d7dh9"), Ok(("", Dice::new(8, 7, KeepOrDrop::None))));
|
||||
assert_eq!(parse_dice("8d7dh8"), Ok(("", Dice::new(8, 7, KeepOrDrop::None))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -315,9 +219,7 @@ mod tests {
|
|||
Ok((
|
||||
"",
|
||||
ElementExpression(vec![SignedElement::Positive(Element::Dice(Dice::new(
|
||||
8,
|
||||
4,
|
||||
KeepOrDrop::None
|
||||
8, 4, KeepOrDrop::None
|
||||
)))])
|
||||
))
|
||||
);
|
||||
|
|
@ -336,9 +238,7 @@ mod tests {
|
|||
Ok((
|
||||
" \n ",
|
||||
ElementExpression(vec![SignedElement::Negative(Element::Dice(Dice::new(
|
||||
8,
|
||||
4,
|
||||
KeepOrDrop::None
|
||||
8, 4, KeepOrDrop::None
|
||||
)))])
|
||||
))
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
use matrix_sdk::ruma::room_id;
|
||||
use matrix_sdk::identifiers::room_id;
|
||||
use matrix_sdk::Client;
|
||||
use tenebrous_dicebot::commands;
|
||||
use tenebrous_dicebot::commands::ResponseExtractor;
|
||||
|
|
@ -29,7 +29,7 @@ async fn main() -> Result<(), BotError> {
|
|||
let context = Context {
|
||||
db,
|
||||
account: Account::default(),
|
||||
matrix_client: Client::new(homeserver).await.expect("Could not create matrix client"),
|
||||
matrix_client: Client::new(homeserver).expect("Could not create matrix client"),
|
||||
origin_room: RoomContext {
|
||||
id: &room_id!("!fakeroomid:example.com"),
|
||||
display_name: "fake room".to_owned(),
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ async fn init(config_path: &str) -> Result<(Arc<Config>, Database, Client), BotE
|
|||
let cfg = Arc::new(cfg);
|
||||
let sqlite_path = format!("{}/dicebot.sqlite", cfg.database_path());
|
||||
let db = Database::new(&sqlite_path).await?;
|
||||
let client = tenebrous_dicebot::matrix::create_client(&cfg).await?;
|
||||
let client = tenebrous_dicebot::matrix::create_client(&cfg)?;
|
||||
Ok((cfg, db, client))
|
||||
}
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ async fn run() -> Result<(), BotError> {
|
|||
|
||||
match try_join!(bot, grpc) {
|
||||
Ok(_) => (),
|
||||
Err(e) => error!("Error: {:?}", e),
|
||||
Err(e) => error!("Error: {}", e),
|
||||
};
|
||||
|
||||
Ok(())
|
||||
|
|
|
|||
|
|
@ -8,8 +8,12 @@ use crate::{
|
|||
models::Account,
|
||||
};
|
||||
use futures::stream::{self, StreamExt};
|
||||
use matrix_sdk::ruma::{OwnedEventId, RoomId};
|
||||
use matrix_sdk::{self, room::Joined, Client};
|
||||
use matrix_sdk::{
|
||||
self,
|
||||
identifiers::{EventId, RoomId},
|
||||
room::Joined,
|
||||
Client,
|
||||
};
|
||||
use std::clone::Clone;
|
||||
use std::convert::TryFrom;
|
||||
|
||||
|
|
@ -20,7 +24,7 @@ pub(super) async fn handle_single_result(
|
|||
cmd_result: &ExecutionResult,
|
||||
respond_to: &str,
|
||||
room: &Joined,
|
||||
event_id: OwnedEventId,
|
||||
event_id: EventId,
|
||||
) {
|
||||
let html = cmd_result.message_html(respond_to);
|
||||
let plain = cmd_result.message_plain(respond_to);
|
||||
|
|
@ -108,9 +112,9 @@ fn get_account_active_room(client: &Client, account: &Account) -> Result<Option<
|
|||
let active_room = account
|
||||
.registered_user()
|
||||
.and_then(|u| u.active_room.as_deref())
|
||||
.map(|room_id| <&RoomId>::try_from(room_id))
|
||||
.map(|room_id| RoomId::try_from(room_id))
|
||||
.transpose()?
|
||||
.and_then(|active_room_id| client.get_joined_room(active_room_id));
|
||||
.and_then(|active_room_id| client.get_joined_room(&active_room_id));
|
||||
|
||||
Ok(active_room)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,25 +2,32 @@ use super::DiceBot;
|
|||
use crate::db::sqlite::Database;
|
||||
use crate::db::Rooms;
|
||||
use crate::error::BotError;
|
||||
use async_trait::async_trait;
|
||||
use log::{debug, error, info, warn};
|
||||
use matrix_sdk::ruma::events::room::member::RoomMemberEventContent;
|
||||
use matrix_sdk::ruma::events::{StrippedStateEvent, SyncMessageLikeEvent};
|
||||
use matrix_sdk::{self, room::Room, ruma::events::room::message::RoomMessageEventContent};
|
||||
use matrix_sdk::{Client, DisplayName};
|
||||
use matrix_sdk::{
|
||||
self,
|
||||
events::{
|
||||
room::member::MemberEventContent,
|
||||
room::message::{MessageEventContent, MessageType, TextMessageEventContent},
|
||||
StrippedStateEvent, SyncMessageEvent,
|
||||
},
|
||||
room::Room,
|
||||
EventHandler,
|
||||
};
|
||||
use std::ops::Sub;
|
||||
use std::time::UNIX_EPOCH;
|
||||
use std::time::{Duration, SystemTime};
|
||||
use std::{clone::Clone, time::UNIX_EPOCH};
|
||||
|
||||
/// Check if a message is recent enough to actually process. If the
|
||||
/// message is within "oldest_message_age" seconds, this function
|
||||
/// returns true. If it's older than that, it returns false and logs a
|
||||
/// debug message.
|
||||
fn check_message_age(
|
||||
event: &SyncMessageLikeEvent<RoomMessageEventContent>,
|
||||
event: &SyncMessageEvent<MessageEventContent>,
|
||||
oldest_message_age: u64,
|
||||
) -> bool {
|
||||
let sending_time = event
|
||||
.origin_server_ts()
|
||||
.origin_server_ts
|
||||
.to_system_time()
|
||||
.unwrap_or(UNIX_EPOCH);
|
||||
|
||||
|
|
@ -47,7 +54,7 @@ fn check_message_age(
|
|||
/// the bot left and rejoined quickly.
|
||||
async fn should_process_message<'a>(
|
||||
bot: &DiceBot,
|
||||
event: &SyncMessageLikeEvent<RoomMessageEventContent>,
|
||||
event: &SyncMessageEvent<MessageEventContent>,
|
||||
) -> Result<(String, String), BotError> {
|
||||
//Ignore messages that are older than configured duration.
|
||||
if !check_message_age(event, bot.config.oldest_message_age()) {
|
||||
|
|
@ -61,29 +68,23 @@ async fn should_process_message<'a>(
|
|||
return Err(BotError::ShouldNotProcessError);
|
||||
}
|
||||
|
||||
let msg_body: String = event
|
||||
.as_original()
|
||||
.map(|e| e.content.body())
|
||||
.map(str::to_string)
|
||||
.unwrap_or_else(|| String::new());
|
||||
|
||||
let sender_username: String = format!(
|
||||
"@{}:{}",
|
||||
event.sender().localpart(),
|
||||
event.sender().server_name()
|
||||
);
|
||||
|
||||
// Do not process messages from the bot itself. Otherwise it might
|
||||
// try to execute its own commands.
|
||||
let bot_username = bot
|
||||
.client
|
||||
.user_id()
|
||||
.map(|u| format!("@{}:{}", u.localpart(), u.server_name()))
|
||||
.unwrap_or_default();
|
||||
|
||||
if sender_username == bot_username {
|
||||
return Err(BotError::ShouldNotProcessError);
|
||||
}
|
||||
let (msg_body, sender_username) = if let SyncMessageEvent {
|
||||
content:
|
||||
MessageEventContent {
|
||||
msgtype: MessageType::Text(TextMessageEventContent { body, .. }),
|
||||
..
|
||||
},
|
||||
sender,
|
||||
..
|
||||
} = event
|
||||
{
|
||||
(
|
||||
body.clone(),
|
||||
format!("@{}:{}", sender.localpart(), sender.server_name()),
|
||||
)
|
||||
} else {
|
||||
(String::new(), String::new())
|
||||
};
|
||||
|
||||
Ok((msg_body, sender_username))
|
||||
}
|
||||
|
|
@ -100,64 +101,58 @@ async fn should_process_event(db: &Database, room_id: &str, event_id: &str) -> b
|
|||
})
|
||||
}
|
||||
|
||||
pub(super) async fn on_stripped_state_member(
|
||||
event: StrippedStateEvent<RoomMemberEventContent>,
|
||||
client: Client,
|
||||
room: Room,
|
||||
) {
|
||||
let room = match room {
|
||||
Room::Invited(invited_room) => invited_room,
|
||||
_ => return,
|
||||
};
|
||||
|
||||
if room.own_user_id().as_str() != event.state_key {
|
||||
return;
|
||||
}
|
||||
|
||||
info!(
|
||||
"Autojoining room {}",
|
||||
room.display_name()
|
||||
.await
|
||||
.ok()
|
||||
.unwrap_or_else(|| DisplayName::Named("[error]".to_string()))
|
||||
);
|
||||
|
||||
if let Err(e) = client.join_room_by_id(&room.room_id()).await {
|
||||
warn!("Could not join room: {}", e.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) async fn on_room_message(
|
||||
event: SyncMessageLikeEvent<RoomMessageEventContent>,
|
||||
room: Room,
|
||||
bot: DiceBot,
|
||||
) {
|
||||
let room = match room {
|
||||
Room::Joined(joined_room) => joined_room,
|
||||
_ => return,
|
||||
};
|
||||
|
||||
let room_id = room.room_id().as_str();
|
||||
if !should_process_event(&bot.db, room_id, event.event_id().as_str()).await {
|
||||
return;
|
||||
}
|
||||
|
||||
let (msg_body, sender_username) =
|
||||
if let Ok((msg_body, sender_username)) = should_process_message(&bot, &event).await {
|
||||
(msg_body, sender_username)
|
||||
} else {
|
||||
return;
|
||||
/// This event emitter listens for messages with dice rolling commands.
|
||||
/// Originally adapted from the matrix-rust-sdk examples.
|
||||
#[async_trait]
|
||||
impl EventHandler for DiceBot {
|
||||
async fn on_stripped_state_member(
|
||||
&self,
|
||||
room: Room,
|
||||
event: &StrippedStateEvent<MemberEventContent>,
|
||||
_: Option<MemberEventContent>,
|
||||
) {
|
||||
let room = match room {
|
||||
Room::Invited(invited_room) => invited_room,
|
||||
_ => return,
|
||||
};
|
||||
|
||||
let results = bot
|
||||
.execute_commands(&room, &sender_username, &msg_body)
|
||||
.await;
|
||||
if room.own_user_id().as_str() != event.state_key {
|
||||
return;
|
||||
}
|
||||
|
||||
bot.handle_results(
|
||||
&room,
|
||||
&sender_username,
|
||||
event.event_id().to_owned(),
|
||||
results,
|
||||
)
|
||||
.await;
|
||||
info!(
|
||||
"Autojoining room {}",
|
||||
room.display_name().await.ok().unwrap_or_default()
|
||||
);
|
||||
|
||||
if let Err(e) = self.client.join_room_by_id(&room.room_id()).await {
|
||||
warn!("Could not join room: {}", e.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
async fn on_room_message(&self, room: Room, event: &SyncMessageEvent<MessageEventContent>) {
|
||||
let room = match room {
|
||||
Room::Joined(joined_room) => joined_room,
|
||||
_ => return,
|
||||
};
|
||||
|
||||
let room_id = room.room_id().as_str();
|
||||
if !should_process_event(&self.db, room_id, event.event_id.as_str()).await {
|
||||
return;
|
||||
}
|
||||
|
||||
let (msg_body, sender_username) =
|
||||
if let Ok((msg_body, sender_username)) = should_process_message(self, &event).await {
|
||||
(msg_body, sender_username)
|
||||
} else {
|
||||
return;
|
||||
};
|
||||
|
||||
let results = self
|
||||
.execute_commands(&room, &sender_username, &msg_body)
|
||||
.await;
|
||||
|
||||
self.handle_results(&room, &sender_username, event.event_id.clone(), results)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,12 +5,7 @@ use crate::db::DbState;
|
|||
use crate::error::BotError;
|
||||
use crate::state::DiceBotState;
|
||||
use log::info;
|
||||
use matrix_sdk::room::Room;
|
||||
use matrix_sdk::ruma::events::room::message::RoomMessageEventContent;
|
||||
use matrix_sdk::ruma::events::SyncMessageLikeEvent;
|
||||
use matrix_sdk::ruma::OwnedEventId;
|
||||
use matrix_sdk::{self, room::Joined, Client};
|
||||
use matrix_sdk::config::SyncSettings;
|
||||
use matrix_sdk::{self, identifiers::EventId, room::Joined, Client, SyncSettings};
|
||||
use std::clone::Clone;
|
||||
use std::sync::{Arc, RwLock};
|
||||
|
||||
|
|
@ -23,7 +18,6 @@ const MAX_COMMANDS_PER_MESSAGE: usize = 50;
|
|||
|
||||
/// The DiceBot struct represents an active dice bot. The bot is not
|
||||
/// connected to Matrix until its run() function is called.
|
||||
#[derive(Clone)]
|
||||
pub struct DiceBot {
|
||||
/// A reference to the configuration read in on application start.
|
||||
config: Arc<Config>,
|
||||
|
|
@ -69,14 +63,12 @@ impl DiceBot {
|
|||
let device_id: Option<String> = self.db.get_device_id().await?;
|
||||
let device_id: Option<&str> = device_id.as_deref();
|
||||
|
||||
let no_device_ld_login = || client.login_username(username, password);
|
||||
let device_id_login = |id| client.login_username(username, password).device_id(id);
|
||||
let login = device_id.map_or_else(no_device_ld_login, device_id_login);
|
||||
|
||||
login.send().await?;
|
||||
client
|
||||
.login(username, password, device_id, Some("matrix dice bot"))
|
||||
.await?;
|
||||
|
||||
if device_id.is_none() {
|
||||
let device_id = client.device_id().ok_or(BotError::NoDeviceIdFound)?;
|
||||
let device_id = client.device_id().await.ok_or(BotError::NoDeviceIdFound)?;
|
||||
self.db.set_device_id(device_id.as_str()).await?;
|
||||
info!("Recorded new device ID: {}", device_id.as_str());
|
||||
} else {
|
||||
|
|
@ -87,35 +79,19 @@ impl DiceBot {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
async fn bind_events(&self) {
|
||||
//on room message: need closure to pass bot ref in.
|
||||
self.client
|
||||
.add_event_handler({
|
||||
let bot: DiceBot = self.clone();
|
||||
move |event: SyncMessageLikeEvent<RoomMessageEventContent>, room: Room| {
|
||||
let bot = bot.clone();
|
||||
async move { event_handlers::on_room_message(event, room, bot).await }
|
||||
}
|
||||
});
|
||||
|
||||
//auto-join handler
|
||||
self.client
|
||||
.add_event_handler(event_handlers::on_stripped_state_member);
|
||||
}
|
||||
|
||||
/// Logs the bot in to Matrix and listens for events until program
|
||||
/// terminated, or a panic occurs. Originally adapted from the
|
||||
/// matrix-rust-sdk command bot example.
|
||||
pub async fn run(self) -> Result<(), BotError> {
|
||||
let client = self.client.clone();
|
||||
self.login(&client).await?;
|
||||
self.bind_events().await;
|
||||
|
||||
client.set_event_handler(Box::new(self)).await;
|
||||
info!("Listening for commands");
|
||||
|
||||
// TODO replace with sync_with_callback for cleaner shutdown
|
||||
// process.
|
||||
client.sync(SyncSettings::default()).await?;
|
||||
client.sync(SyncSettings::default()).await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -145,7 +121,7 @@ impl DiceBot {
|
|||
&self,
|
||||
room: &Joined,
|
||||
sender_username: &str,
|
||||
event_id: OwnedEventId,
|
||||
event_id: EventId,
|
||||
results: Vec<(String, ExecutionResult)>,
|
||||
) {
|
||||
if results.len() >= 1 {
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ mod tests {
|
|||
macro_rules! dummy_room {
|
||||
() => {
|
||||
crate::context::RoomContext {
|
||||
id: &matrix_sdk::ruma::room_id!("!fakeroomid:example.com"),
|
||||
id: &matrix_sdk::identifiers::room_id!("!fakeroomid:example.com"),
|
||||
display_name: "displayname".to_owned(),
|
||||
secure: false,
|
||||
}
|
||||
|
|
@ -485,7 +485,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "username",
|
||||
|
|
@ -527,7 +527,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "username",
|
||||
|
|
@ -566,7 +566,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db.clone(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "username",
|
||||
|
|
|
|||
|
|
@ -45,13 +45,13 @@ pub fn parse_modifiers(input: &str) -> Result<DicePoolModifiers, DiceParsingErro
|
|||
let (result, rest) = parser.parse(input)?;
|
||||
|
||||
if rest.len() == 0 {
|
||||
convert_to_modifiers(&result)
|
||||
convert_to_info(&result)
|
||||
} else {
|
||||
Err(DiceParsingError::UnconsumedInput)
|
||||
}
|
||||
}
|
||||
|
||||
fn convert_to_modifiers(parsed: &Vec<ParsedInfo>) -> Result<DicePoolModifiers, DiceParsingError> {
|
||||
fn convert_to_info(parsed: &Vec<ParsedInfo>) -> Result<DicePoolModifiers, DiceParsingError> {
|
||||
use ParsedInfo::*;
|
||||
if parsed.len() == 0 {
|
||||
Ok(DicePoolModifiers::default())
|
||||
|
|
@ -79,8 +79,19 @@ fn convert_to_modifiers(parsed: &Vec<ParsedInfo>) -> Result<DicePoolModifiers, D
|
|||
}
|
||||
|
||||
pub fn parse_dice_pool(input: &str) -> Result<DicePool, BotError> {
|
||||
let (amounts, modifiers_str) = parse_amounts(input)?;
|
||||
//The "modifiers:" part is optional. Assume amounts if no modifier
|
||||
//section found.
|
||||
let split = input.split(":").collect::<Vec<_>>();
|
||||
let (modifiers_str, amounts_str) = (match split[..] {
|
||||
[amounts] => Ok(("", amounts)),
|
||||
[modifiers, amounts] => Ok((modifiers, amounts)),
|
||||
_ => Err(BotError::DiceParsingError(
|
||||
DiceParsingError::UnconsumedInput,
|
||||
)),
|
||||
})?;
|
||||
|
||||
let modifiers = parse_modifiers(modifiers_str)?;
|
||||
let amounts = parse_amounts(&amounts_str)?;
|
||||
Ok(DicePool::new(amounts, modifiers))
|
||||
}
|
||||
|
||||
|
|
@ -164,7 +175,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn dice_pool_number_with_quality() {
|
||||
let result = parse_dice_pool("8 n");
|
||||
let result = parse_dice_pool("n:8");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
|
|
@ -175,7 +186,7 @@ mod tests {
|
|||
#[test]
|
||||
fn dice_pool_number_with_success_change() {
|
||||
let modifiers = DicePoolModifiers::custom_exceptional_on(3);
|
||||
let result = parse_dice_pool("8 s3");
|
||||
let result = parse_dice_pool("s3:8");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(result.unwrap(), DicePool::easy_with_modifiers(8, modifiers));
|
||||
}
|
||||
|
|
@ -183,7 +194,7 @@ mod tests {
|
|||
#[test]
|
||||
fn dice_pool_with_quality_and_success_change() {
|
||||
let modifiers = DicePoolModifiers::custom(DicePoolQuality::Rote, 3);
|
||||
let result = parse_dice_pool("8 rs3");
|
||||
let result = parse_dice_pool("rs3:8");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(result.unwrap(), DicePool::easy_with_modifiers(8, modifiers));
|
||||
}
|
||||
|
|
@ -213,20 +224,20 @@ mod tests {
|
|||
|
||||
let expected = DicePool::new(amounts, modifiers);
|
||||
|
||||
let result = parse_dice_pool("8+10-2+varname rs3");
|
||||
let result = parse_dice_pool("rs3:8+10-2+varname");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(result.unwrap(), expected);
|
||||
|
||||
let result = parse_dice_pool("8+10- 2 + varname rs3");
|
||||
let result = parse_dice_pool("rs3:8+10- 2 + varname");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(result.unwrap(), expected);
|
||||
|
||||
let result = parse_dice_pool("8+ 10 -2 + varname rs3");
|
||||
let result = parse_dice_pool("rs3 : 8+ 10 -2 + varname");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(result.unwrap(), expected);
|
||||
|
||||
//This one has tabs in it.
|
||||
let result = parse_dice_pool(" 8 + 10 -2 + varname r s3");
|
||||
let result = parse_dice_pool(" r s3 : 8 + 10 -2 + varname");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(result.unwrap(), expected);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -162,12 +162,11 @@ mod tests {
|
|||
use super::*;
|
||||
use management::RegisterCommand;
|
||||
use url::Url;
|
||||
use matrix_sdk::ruma::room_id;
|
||||
|
||||
macro_rules! dummy_room {
|
||||
() => {
|
||||
crate::context::RoomContext {
|
||||
id: &room_id!("!fakeroomid:example.com"),
|
||||
id: &matrix_sdk::identifiers::room_id!("!fakeroomid:example.com"),
|
||||
display_name: "displayname".to_owned(),
|
||||
secure: false,
|
||||
}
|
||||
|
|
@ -177,7 +176,7 @@ mod tests {
|
|||
macro_rules! secure_room {
|
||||
() => {
|
||||
crate::context::RoomContext {
|
||||
id: &room_id!("!fakeroomid:example.com"),
|
||||
id: &matrix_sdk::identifiers::room_id!("!fakeroomid:example.com"),
|
||||
display_name: "displayname".to_owned(),
|
||||
secure: true,
|
||||
}
|
||||
|
|
@ -196,7 +195,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: secure_room!(),
|
||||
active_room: secure_room!(),
|
||||
username: "myusername",
|
||||
|
|
@ -219,7 +218,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: secure_room!(),
|
||||
active_room: secure_room!(),
|
||||
username: "myusername",
|
||||
|
|
@ -242,7 +241,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "myusername",
|
||||
|
|
@ -265,7 +264,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "myusername",
|
||||
|
|
@ -288,7 +287,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "myusername",
|
||||
|
|
|
|||
|
|
@ -221,9 +221,9 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn pool_whitespace_test() {
|
||||
parse_command("!pool 8 ns3 ").expect("was error");
|
||||
parse_command(" !pool 8 ns3").expect("was error");
|
||||
parse_command(" !pool 8 ns3 ").expect("was error");
|
||||
parse_command("!pool ns3:8 ").expect("was error");
|
||||
parse_command(" !pool ns3:8").expect("was error");
|
||||
parse_command(" !pool ns3:8 ").expect("was error");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ use crate::matrix;
|
|||
use async_trait::async_trait;
|
||||
use fuse_rust::{Fuse, FuseProperty, Fuseable};
|
||||
use futures::stream::{self, StreamExt, TryStreamExt};
|
||||
use matrix_sdk::{ruma::OwnedUserId, Client};
|
||||
use matrix_sdk::{identifiers::UserId, Client};
|
||||
use std::convert::TryFrom;
|
||||
|
||||
/// Holds matrix room ID and display name as strings, for use with
|
||||
|
|
@ -62,13 +62,13 @@ async fn get_rooms_for_user(
|
|||
client: &Client,
|
||||
user_id: &str,
|
||||
) -> Result<Vec<RoomNameAndId>, BotError> {
|
||||
let user_id = OwnedUserId::try_from(user_id)?;
|
||||
let user_id = UserId::try_from(user_id)?;
|
||||
let rooms_for_user = matrix::get_rooms_for_user(client, &user_id).await?;
|
||||
let mut rooms_for_user: Vec<RoomNameAndId> = stream::iter(rooms_for_user)
|
||||
.filter_map(|room| async move {
|
||||
Some(room.display_name().await.map(|room_name| RoomNameAndId {
|
||||
id: room.room_id().to_string(),
|
||||
name: room_name.to_string(),
|
||||
name: room_name,
|
||||
}))
|
||||
})
|
||||
.try_collect()
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
use crate::db::sqlite::Database;
|
||||
use crate::error::BotError;
|
||||
use crate::models::Account;
|
||||
use matrix_sdk::identifiers::{RoomId, UserId};
|
||||
use matrix_sdk::room::Joined;
|
||||
use matrix_sdk::ruma::{RoomId, UserId};
|
||||
use matrix_sdk::Client;
|
||||
use std::convert::TryFrom;
|
||||
|
||||
|
|
@ -48,16 +48,15 @@ impl RoomContext<'_> {
|
|||
// TODO is_direct is a hack; the bot should set eligible rooms
|
||||
// to Direct Message upon joining, if other contact has
|
||||
// requested it. Waiting on SDK support.
|
||||
let display_name =
|
||||
room
|
||||
let display_name = room
|
||||
.display_name()
|
||||
.await
|
||||
.ok()
|
||||
.map(|d| d.to_string())
|
||||
.unwrap_or_default();
|
||||
.unwrap_or_default()
|
||||
.to_string();
|
||||
|
||||
let sending_user = <&UserId>::try_from(sending_user)?;
|
||||
let user_in_room = room.get_member(sending_user).await.ok().is_some();
|
||||
let sending_user = UserId::try_from(sending_user)?;
|
||||
let user_in_room = room.get_member(&sending_user).await.ok().is_some();
|
||||
let is_direct = room.active_members().await?.len() == 2;
|
||||
|
||||
Ok(RoomContext {
|
||||
|
|
|
|||
|
|
@ -270,7 +270,7 @@ macro_rules! is_variable {
|
|||
element: Element::Variable(_),
|
||||
..
|
||||
}
|
||||
)
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -427,12 +427,11 @@ mod tests {
|
|||
use crate::db::sqlite::Database;
|
||||
use crate::parser::dice::{Amount, Element, Operator};
|
||||
use url::Url;
|
||||
use matrix_sdk::ruma::room_id;
|
||||
|
||||
macro_rules! dummy_room {
|
||||
() => {
|
||||
crate::context::RoomContext {
|
||||
id: &room_id!("!fakeroomid:example.com"),
|
||||
id: &matrix_sdk::identifiers::room_id!("!fakeroomid:example.com"),
|
||||
display_name: "displayname".to_owned(),
|
||||
secure: false,
|
||||
}
|
||||
|
|
@ -512,7 +511,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "username",
|
||||
|
|
@ -550,7 +549,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "username",
|
||||
|
|
@ -588,7 +587,7 @@ mod tests {
|
|||
let ctx = Context {
|
||||
account: crate::models::Account::default(),
|
||||
db: db,
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
||||
matrix_client: matrix_sdk::Client::new(homeserver).unwrap(),
|
||||
origin_room: dummy_room!(),
|
||||
active_room: dummy_room!(),
|
||||
username: "username",
|
||||
|
|
|
|||
|
|
@ -4,13 +4,16 @@ use crate::parser::dice::DiceParsingError;
|
|||
//TOOD convert these to use parse_amounts from the common dice code.
|
||||
|
||||
fn parse_modifier(input: &str) -> Result<DiceRollModifier, DiceParsingError> {
|
||||
match input.trim() {
|
||||
"bb" => Ok(DiceRollModifier::TwoBonus),
|
||||
"b" => Ok(DiceRollModifier::OneBonus),
|
||||
"pp" => Ok(DiceRollModifier::TwoPenalty),
|
||||
"p" => Ok(DiceRollModifier::OnePenalty),
|
||||
"" => Ok(DiceRollModifier::Normal),
|
||||
_ => Err(DiceParsingError::InvalidModifiers),
|
||||
if input.ends_with("bb") {
|
||||
Ok(DiceRollModifier::TwoBonus)
|
||||
} else if input.ends_with("b") {
|
||||
Ok(DiceRollModifier::OneBonus)
|
||||
} else if input.ends_with("pp") {
|
||||
Ok(DiceRollModifier::TwoPenalty)
|
||||
} else if input.ends_with("p") {
|
||||
Ok(DiceRollModifier::OnePenalty)
|
||||
} else {
|
||||
Ok(DiceRollModifier::Normal)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -18,70 +21,32 @@ fn parse_modifier(input: &str) -> Result<DiceRollModifier, DiceParsingError> {
|
|||
//Split based on :, send first part to parse_modifier.
|
||||
//Send second part to parse_amounts
|
||||
pub fn parse_regular_roll(input: &str) -> Result<DiceRoll, DiceParsingError> {
|
||||
let (amount, modifiers_str) = crate::parser::dice::parse_single_amount(input)?;
|
||||
let input: Vec<&str> = input.trim().split(":").collect();
|
||||
|
||||
let (modifiers_str, amounts_str) = match input[..] {
|
||||
[amounts] => Ok(("", amounts)),
|
||||
[modifiers, amounts] => Ok((modifiers, amounts)),
|
||||
_ => Err(DiceParsingError::UnconsumedInput),
|
||||
}?;
|
||||
|
||||
let modifier = parse_modifier(modifiers_str)?;
|
||||
let amount = crate::parser::dice::parse_single_amount(amounts_str)?;
|
||||
Ok(DiceRoll { modifier, amount })
|
||||
}
|
||||
|
||||
pub fn parse_advancement_roll(input: &str) -> Result<AdvancementRoll, DiceParsingError> {
|
||||
let input = input.trim();
|
||||
let (amounts, unconsumed_input) = crate::parser::dice::parse_single_amount(input)?;
|
||||
let amounts = crate::parser::dice::parse_single_amount(input)?;
|
||||
|
||||
if unconsumed_input.len() == 0 {
|
||||
Ok(AdvancementRoll {
|
||||
existing_skill: amounts,
|
||||
})
|
||||
} else {
|
||||
Err(DiceParsingError::InvalidAmount)
|
||||
}
|
||||
Ok(AdvancementRoll {
|
||||
existing_skill: amounts,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::parser::dice::{Amount, DiceParsingError, Element, Operator};
|
||||
|
||||
#[test]
|
||||
fn parse_modifier_rejects_bad_value() {
|
||||
let modifier = parse_modifier("qqq");
|
||||
assert!(matches!(modifier, Err(DiceParsingError::InvalidModifiers)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_modifier_accepts_one_bonus() {
|
||||
let modifier = parse_modifier("b");
|
||||
assert!(matches!(modifier, Ok(DiceRollModifier::OneBonus)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_modifier_accepts_two_bonus() {
|
||||
let modifier = parse_modifier("bb");
|
||||
assert!(matches!(modifier, Ok(DiceRollModifier::TwoBonus)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_modifier_accepts_two_penalty() {
|
||||
let modifier = parse_modifier("pp");
|
||||
assert!(matches!(modifier, Ok(DiceRollModifier::TwoPenalty)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_modifier_accepts_one_penalty() {
|
||||
let modifier = parse_modifier("p");
|
||||
assert!(matches!(modifier, Ok(DiceRollModifier::OnePenalty)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_modifier_accepts_normal() {
|
||||
let modifier = parse_modifier("");
|
||||
assert!(matches!(modifier, Ok(DiceRollModifier::Normal)))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_modifier_accepts_normal_unaffected_by_whitespace() {
|
||||
let modifier = parse_modifier(" ");
|
||||
assert!(matches!(modifier, Ok(DiceRollModifier::Normal)))
|
||||
}
|
||||
use crate::parser::dice::{Amount, Element, Operator};
|
||||
|
||||
#[test]
|
||||
fn regular_roll_accepts_single_number() {
|
||||
|
|
@ -107,7 +72,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_two_bonus() {
|
||||
let result = parse_regular_roll("60 bb");
|
||||
let result = parse_regular_roll("bb:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
|
|
@ -123,7 +88,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_one_bonus() {
|
||||
let result = parse_regular_roll("60 b");
|
||||
let result = parse_regular_roll("b:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
|
|
@ -139,7 +104,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_two_penalty() {
|
||||
let result = parse_regular_roll("60 pp");
|
||||
let result = parse_regular_roll("pp:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
|
|
@ -155,7 +120,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_one_penalty() {
|
||||
let result = parse_regular_roll("60 p");
|
||||
let result = parse_regular_roll("p:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
|
|
@ -175,21 +140,21 @@ mod tests {
|
|||
assert!(parse_regular_roll(" 60").is_ok());
|
||||
assert!(parse_regular_roll(" 60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60bb ").is_ok());
|
||||
assert!(parse_regular_roll(" 60 bb").is_ok());
|
||||
assert!(parse_regular_roll(" 60 bb ").is_ok());
|
||||
assert!(parse_regular_roll("bb:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" bb:60").is_ok());
|
||||
assert!(parse_regular_roll(" bb:60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60b ").is_ok());
|
||||
assert!(parse_regular_roll(" 60 b").is_ok());
|
||||
assert!(parse_regular_roll(" 60 b ").is_ok());
|
||||
assert!(parse_regular_roll("b:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" b:60").is_ok());
|
||||
assert!(parse_regular_roll(" b:60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60pp ").is_ok());
|
||||
assert!(parse_regular_roll(" 60 pp").is_ok());
|
||||
assert!(parse_regular_roll(" 60 pp ").is_ok());
|
||||
assert!(parse_regular_roll("pp:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" pp:60").is_ok());
|
||||
assert!(parse_regular_roll(" pp:60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60p ").is_ok());
|
||||
assert!(parse_regular_roll(" 60p ").is_ok());
|
||||
assert!(parse_regular_roll(" 60 p ").is_ok());
|
||||
assert!(parse_regular_roll("p:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" p:60").is_ok());
|
||||
assert!(parse_regular_roll(" p:60 ").is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -1,22 +0,0 @@
|
|||
use crate::systems::GameSystem;
|
||||
use barrel::backend::Sqlite;
|
||||
use barrel::{types, types::Type, Migration};
|
||||
use itertools::Itertools;
|
||||
use strum::IntoEnumIterator;
|
||||
|
||||
fn primary_id() -> Type {
|
||||
types::text().unique(true).primary(true).nullable(false)
|
||||
}
|
||||
|
||||
pub fn migration() -> String {
|
||||
let mut m = Migration::new();
|
||||
|
||||
//Normally we would add a CHECK clause here, but types::custom requires a 'static string.
|
||||
//Which means we can't automagically generate one from the enum.
|
||||
m.create_table("room_info", move |t| {
|
||||
t.add_column("room_id", primary_id());
|
||||
t.add_column("game_system", types::text().nullable(false));
|
||||
});
|
||||
|
||||
m.make::<Sqlite>()
|
||||
}
|
||||
|
|
@ -1 +1,2 @@
|
|||
|
||||
use refinery::include_migration_mods;
|
||||
include_migration_mods!("src/db/sqlite/migrator/migrations");
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ use sqlx::ConnectOptions;
|
|||
use std::str::FromStr;
|
||||
use thiserror::Error;
|
||||
|
||||
//pub mod migrations;
|
||||
pub mod migrations;
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum MigrationError {
|
||||
|
|
@ -16,11 +16,6 @@ pub enum MigrationError {
|
|||
RefineryError(#[from] refinery::Error),
|
||||
}
|
||||
|
||||
mod embedded {
|
||||
use refinery::embed_migrations;
|
||||
embed_migrations!("src/db/sqlite/migrator/migrations");
|
||||
}
|
||||
|
||||
/// Run database migrations against the sqlite database.
|
||||
pub async fn migrate(db_path: &str) -> Result<(), MigrationError> {
|
||||
//Create database if missing.
|
||||
|
|
@ -33,6 +28,6 @@ pub async fn migrate(db_path: &str) -> Result<(), MigrationError> {
|
|||
|
||||
let mut conn = Config::new(ConfigDbType::Sqlite).set_db_path(db_path);
|
||||
info!("Running migrations");
|
||||
embedded::migrations::runner().run(&mut conn)?;
|
||||
migrations::runner().run(&mut conn)?;
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,12 +18,6 @@ pub enum BotError {
|
|||
#[error("could not retrieve device id")]
|
||||
NoDeviceIdFound,
|
||||
|
||||
#[error("could not build client: {0}")]
|
||||
ClientBuildError(#[from] matrix_sdk::ClientBuildError),
|
||||
|
||||
#[error("could not open matrix store: {0}")]
|
||||
OpenStoreError(#[from] matrix_sdk::store::OpenStoreError),
|
||||
|
||||
#[error("command error: {0}")]
|
||||
CommandError(#[from] CommandError),
|
||||
|
||||
|
|
@ -39,15 +33,15 @@ pub enum BotError {
|
|||
#[error("could not parse URL")]
|
||||
UrlParseError(#[from] url::ParseError),
|
||||
|
||||
#[error("could not parse ID")]
|
||||
IdParseError(#[from] matrix_sdk::ruma::IdParseError),
|
||||
|
||||
#[error("error in matrix state store: {0}")]
|
||||
MatrixStateStoreError(#[from] matrix_sdk::StoreError),
|
||||
|
||||
#[error("uncategorized matrix SDK error: {0}")]
|
||||
MatrixError(#[from] matrix_sdk::Error),
|
||||
|
||||
#[error("uncategorized matrix SDK base error: {0}")]
|
||||
MatrixBaseError(#[from] matrix_sdk::BaseError),
|
||||
|
||||
#[error("future canceled")]
|
||||
FutureCanceledError,
|
||||
|
||||
|
|
@ -85,8 +79,8 @@ pub enum BotError {
|
|||
#[error("could not convert to proper integer type")]
|
||||
TryFromIntError(#[from] std::num::TryFromIntError),
|
||||
|
||||
// #[error("identifier error: {0}")]
|
||||
// IdentifierError(#[from] matrix_sdk::ruma::Error),
|
||||
#[error("identifier error: {0}")]
|
||||
IdentifierError(#[from] matrix_sdk::identifiers::Error),
|
||||
|
||||
#[error("password creation error: {0}")]
|
||||
PasswordCreationError(argon2::Error),
|
||||
|
|
|
|||
|
|
@ -6,9 +6,6 @@ pub fn parse_help_topic(input: &str) -> Option<HelpTopic> {
|
|||
"dicepool" => Some(HelpTopic::DicePool),
|
||||
"dice" => Some(HelpTopic::RollingDice),
|
||||
"cthulhu" => Some(HelpTopic::Cthulhu),
|
||||
"variables" => Some(HelpTopic::Variables),
|
||||
"var" => Some(HelpTopic::Variables),
|
||||
"variable" => Some(HelpTopic::Variables),
|
||||
"" => Some(HelpTopic::General),
|
||||
_ => None,
|
||||
}
|
||||
|
|
@ -19,7 +16,6 @@ pub enum HelpTopic {
|
|||
DicePool,
|
||||
Cthulhu,
|
||||
RollingDice,
|
||||
Variables,
|
||||
General,
|
||||
}
|
||||
|
||||
|
|
@ -105,34 +101,6 @@ Note: If !cthadv is given a variable, and the roll is successful, it will
|
|||
update the variable with the new skill.
|
||||
"};
|
||||
|
||||
const VARIABLES_HELP: &'static str = indoc! {"
|
||||
Variables
|
||||
|
||||
Commands: !get, !set, !variables
|
||||
|
||||
Manage variables that can be substituted into roll commands.
|
||||
|
||||
Examples: !get myvar, !set myvar 10
|
||||
|
||||
!get <variable> = show variable of the given name
|
||||
!set <variable> <num> = set a variable to a number
|
||||
|
||||
The !variables command will list all variables for the room. The
|
||||
variables command cna be used in a secure room to avoid spamming the
|
||||
actual room that the variable is set in.
|
||||
|
||||
Variable names can be used in all types of dice rolls:
|
||||
|
||||
!pool myvar + 3
|
||||
!roll myvar
|
||||
|
||||
There are some limitations on variables: they cannot themselves be
|
||||
dice expressions (i.e. can only be numbers), and they must be uniquely
|
||||
parseable in an expression (i.e 'myvard6' does not work for the !roll
|
||||
command).
|
||||
|
||||
"};
|
||||
|
||||
const GENERAL_HELP: &'static str = indoc! {"
|
||||
General Help
|
||||
|
||||
|
|
@ -149,7 +117,6 @@ impl HelpTopic {
|
|||
HelpTopic::DicePool => DICEPOOL_HELP,
|
||||
HelpTopic::Cthulhu => CTHULHU_HELP,
|
||||
HelpTopic::RollingDice => DICE_HELP,
|
||||
HelpTopic::Variables => VARIABLES_HELP,
|
||||
HelpTopic::General => GENERAL_HELP,
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,4 +14,3 @@ pub mod models;
|
|||
mod parser;
|
||||
pub mod rpc;
|
||||
pub mod state;
|
||||
pub mod systems;
|
||||
|
|
|
|||
|
|
@ -2,12 +2,15 @@ use std::path::PathBuf;
|
|||
|
||||
use futures::stream::{self, StreamExt, TryStreamExt};
|
||||
use log::error;
|
||||
use matrix_sdk::ruma::events::room::message::{InReplyTo, RoomMessageEventContent, Relation};
|
||||
use matrix_sdk::ruma::events::AnyMessageLikeEventContent;
|
||||
use matrix_sdk::ruma::{RoomId, OwnedEventId, OwnedUserId};
|
||||
use matrix_sdk::Client;
|
||||
use matrix_sdk::Error as MatrixError;
|
||||
use matrix_sdk::room::Joined;
|
||||
use matrix_sdk::{events::room::message::NoticeMessageEventContent, room::Joined, ClientConfig};
|
||||
use matrix_sdk::{
|
||||
events::room::message::{InReplyTo, Relation},
|
||||
events::room::message::{MessageEventContent, MessageType},
|
||||
events::AnyMessageEventContent,
|
||||
identifiers::EventId,
|
||||
Error as MatrixError,
|
||||
};
|
||||
use matrix_sdk::{identifiers::RoomId, identifiers::UserId, Client};
|
||||
use url::Url;
|
||||
|
||||
use crate::{config::Config, error::BotError};
|
||||
|
|
@ -29,16 +32,12 @@ fn extract_error_message(error: MatrixError) -> String {
|
|||
}
|
||||
|
||||
/// Creates the matrix client.
|
||||
pub async fn create_client(config: &Config) -> Result<Client, BotError> {
|
||||
pub fn create_client(config: &Config) -> Result<Client, BotError> {
|
||||
let cache_dir = cache_dir()?;
|
||||
let client_config = ClientConfig::new().store_path(cache_dir);
|
||||
let homeserver_url = Url::parse(&config.matrix_homeserver())?;
|
||||
|
||||
let client = Client::builder()
|
||||
.sled_store(cache_dir, None)?
|
||||
.homeserver_url(homeserver_url).build()
|
||||
.await?;
|
||||
|
||||
Ok(client)
|
||||
Ok(Client::new_with_config(homeserver_url, client_config)?)
|
||||
}
|
||||
|
||||
/// Retrieve a list of users in a given room.
|
||||
|
|
@ -60,7 +59,7 @@ pub async fn get_users_in_room(
|
|||
|
||||
pub async fn get_rooms_for_user(
|
||||
client: &Client,
|
||||
user: &OwnedUserId,
|
||||
user: &UserId,
|
||||
) -> Result<Vec<Joined>, MatrixError> {
|
||||
// Carries errors through, in case we cannot load joined user IDs
|
||||
// from the room for some reason.
|
||||
|
|
@ -88,7 +87,7 @@ pub async fn send_message(
|
|||
client: &Client,
|
||||
room_id: &RoomId,
|
||||
message: (&str, &str),
|
||||
reply_to: Option<OwnedEventId>,
|
||||
reply_to: Option<EventId>,
|
||||
) {
|
||||
let (html, plain) = message;
|
||||
let room = match client.get_joined_room(room_id) {
|
||||
|
|
@ -96,13 +95,15 @@ pub async fn send_message(
|
|||
_ => return,
|
||||
};
|
||||
|
||||
let mut content = RoomMessageEventContent::notice_html(plain.trim(), html);
|
||||
let mut content = MessageEventContent::new(MessageType::Notice(
|
||||
NoticeMessageEventContent::html(plain.trim(), html),
|
||||
));
|
||||
|
||||
content.relates_to = reply_to.map(|event_id| Relation::Reply {
|
||||
in_reply_to: InReplyTo::new(event_id)
|
||||
in_reply_to: InReplyTo::new(event_id),
|
||||
});
|
||||
|
||||
let content = AnyMessageLikeEventContent::RoomMessage(content);
|
||||
let content = AnyMessageEventContent::RoomMessage(content);
|
||||
|
||||
let result = room.send(content, None).await;
|
||||
|
||||
|
|
|
|||
|
|
@ -151,9 +151,8 @@ where
|
|||
/// should not have an operator, but every one after that should.
|
||||
/// Accepts expressions like "8", "10 + variablename", "variablename -
|
||||
/// 3", etc. This function is currently common to systems that don't
|
||||
/// deal with XdY rolls. Support for that will be added later. Returns
|
||||
/// parsed amounts and unconsumed input (e.g. roll modifiers).
|
||||
pub fn parse_amounts(input: &str) -> ParseResult<(Vec<Amount>, &str)> {
|
||||
/// deal with XdY rolls. Support for that will be added later.
|
||||
pub fn parse_amounts(input: &str) -> ParseResult<Vec<Amount>> {
|
||||
let input = input.trim();
|
||||
|
||||
let remaining_amounts = many(amount_parser()).map(|amounts: Vec<ParseResult<Amount>>| amounts);
|
||||
|
|
@ -170,23 +169,31 @@ pub fn parse_amounts(input: &str) -> ParseResult<(Vec<Amount>, &str)> {
|
|||
(amounts, results.1)
|
||||
})?;
|
||||
|
||||
// Any ParseResult errors will short-circuit the collect.
|
||||
let results: Vec<Amount> = results.into_iter().collect::<ParseResult<_>>()?;
|
||||
Ok((results, rest))
|
||||
if rest.len() == 0 {
|
||||
// Any ParseResult errors will short-circuit the collect.
|
||||
results.into_iter().collect()
|
||||
} else {
|
||||
Err(DiceParsingError::UnconsumedInput)
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse an expression that expects a single number or variable. No
|
||||
/// operators are allowed. This function is common to systems that
|
||||
/// don't deal with XdY rolls. Currently. this function does not
|
||||
/// support parsing negative numbers. Returns the parsed amount and
|
||||
/// any unconsumed input (useful for dice roll modifiers).
|
||||
pub fn parse_single_amount(input: &str) -> ParseResult<(Amount, &str)> {
|
||||
/// support parsing negative numbers.
|
||||
pub fn parse_single_amount(input: &str) -> ParseResult<Amount> {
|
||||
// TODO add support for negative numbers, as technically they
|
||||
// should be allowed.
|
||||
let input = input.trim();
|
||||
let mut parser = first_amount_parser().map(|amount: ParseResult<Amount>| amount);
|
||||
|
||||
let (result, rest) = parser.parse(input)?;
|
||||
Ok((result?, rest))
|
||||
|
||||
if rest.len() == 0 {
|
||||
result
|
||||
} else {
|
||||
Err(DiceParsingError::UnconsumedInput)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -199,13 +206,10 @@ mod parse_single_amount_tests {
|
|||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
(
|
||||
Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Variable("abc".to_string())
|
||||
},
|
||||
""
|
||||
)
|
||||
Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Variable("abc".to_string())
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
|
|
@ -229,15 +233,24 @@ mod parse_single_amount_tests {
|
|||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
(
|
||||
Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(1)
|
||||
},
|
||||
""
|
||||
)
|
||||
Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(1)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_multiple_elements_test() {
|
||||
let result = parse_single_amount("1+abc");
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = parse_single_amount("abc+1");
|
||||
assert!(result.is_err());
|
||||
|
||||
let result = parse_single_amount("-1-abc");
|
||||
assert!(result.is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
|
@ -250,26 +263,20 @@ mod parse_many_amounts_tests {
|
|||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
(
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(1)
|
||||
}],
|
||||
""
|
||||
)
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(1)
|
||||
}]
|
||||
);
|
||||
|
||||
let result = parse_amounts("10");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
(
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(10)
|
||||
}],
|
||||
""
|
||||
)
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(10)
|
||||
}]
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -288,26 +295,20 @@ mod parse_many_amounts_tests {
|
|||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
(
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Variable("asdf".to_string())
|
||||
}],
|
||||
""
|
||||
)
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Variable("asdf".to_string())
|
||||
}]
|
||||
);
|
||||
|
||||
let result = parse_amounts("nosis");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
result.unwrap(),
|
||||
(
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Variable("nosis".to_string())
|
||||
}],
|
||||
""
|
||||
)
|
||||
vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Variable("nosis".to_string())
|
||||
}]
|
||||
);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,8 +4,7 @@ use crate::matrix;
|
|||
use crate::{config::Config, db::sqlite::Database};
|
||||
use futures::stream;
|
||||
use futures::{StreamExt, TryFutureExt, TryStreamExt};
|
||||
use matrix_sdk::ruma::OwnedUserId;
|
||||
use matrix_sdk::{room::Joined, Client};
|
||||
use matrix_sdk::{identifiers::UserId, room::Joined, Client};
|
||||
use std::convert::TryFrom;
|
||||
use std::sync::Arc;
|
||||
use tenebrous_rpc::protos::dicebot::{
|
||||
|
|
@ -85,7 +84,7 @@ impl Dicebot for DicebotRpcService {
|
|||
request: Request<UserIdRequest>,
|
||||
) -> Result<Response<RoomsListReply>, Status> {
|
||||
let UserIdRequest { user_id } = request.into_inner();
|
||||
let user_id = OwnedUserId::try_from(user_id).map_err(BotError::from)?;
|
||||
let user_id = UserId::try_from(user_id).map_err(BotError::from)?;
|
||||
|
||||
let rooms_for_user = matrix::get_rooms_for_user(&self.client, &user_id)
|
||||
.err_into::<BotError>()
|
||||
|
|
@ -95,7 +94,7 @@ impl Dicebot for DicebotRpcService {
|
|||
.filter_map(|room: Joined| async move {
|
||||
let room: Result<Room, _> = room.display_name().await.map(|room_name| Room {
|
||||
room_id: room.room_id().to_string(),
|
||||
display_name: room_name.to_string(),
|
||||
display_name: room_name,
|
||||
});
|
||||
|
||||
Some(room)
|
||||
|
|
|
|||
|
|
@ -1,21 +0,0 @@
|
|||
use strum::{AsRefStr, Display, EnumIter, EnumString};
|
||||
|
||||
#[derive(EnumString, EnumIter, AsRefStr, Display)]
|
||||
pub(crate) enum GameSystem {
|
||||
ChroniclesOfDarkness,
|
||||
Changeling,
|
||||
MageTheAwakening,
|
||||
WerewolfTheForsaken,
|
||||
DeviantTheRenegades,
|
||||
MummyTheCurse,
|
||||
PrometheanTheCreated,
|
||||
CallOfCthulhu,
|
||||
DungeonsAndDragons5e,
|
||||
DungeonsAndDragons4e,
|
||||
DungeonsAndDragons35e,
|
||||
DungeonsAndDragons2e,
|
||||
DungeonsAndDragons1e,
|
||||
None,
|
||||
}
|
||||
|
||||
impl GameSystem {}
|
||||
Loading…
Reference in New Issue