mirror of
https://github.com/youwen5/iamb.git
synced 2025-06-19 21:29:52 -07:00
666 lines
20 KiB
Rust
666 lines
20 KiB
Rust
use std::borrow::Cow;
|
||
use std::cmp::{Ord, Ordering, PartialOrd};
|
||
use std::collections::hash_map::DefaultHasher;
|
||
use std::collections::BTreeMap;
|
||
use std::convert::TryFrom;
|
||
use std::hash::{Hash, Hasher};
|
||
use std::str::Lines;
|
||
|
||
use chrono::{DateTime, NaiveDateTime, Utc};
|
||
use unicode_segmentation::UnicodeSegmentation;
|
||
use unicode_width::UnicodeWidthStr;
|
||
|
||
use matrix_sdk::ruma::{
|
||
events::room::message::{
|
||
MessageType,
|
||
OriginalRoomMessageEvent,
|
||
RedactedRoomMessageEvent,
|
||
RoomMessageEvent,
|
||
RoomMessageEventContent,
|
||
},
|
||
MilliSecondsSinceUnixEpoch,
|
||
OwnedEventId,
|
||
OwnedUserId,
|
||
UInt,
|
||
};
|
||
|
||
use modalkit::tui::{
|
||
style::{Modifier as StyleModifier, Style},
|
||
text::{Span, Spans, Text},
|
||
};
|
||
|
||
use modalkit::editing::{base::ViewportContext, cursor::Cursor};
|
||
|
||
use crate::{
|
||
base::{IambResult, RoomInfo},
|
||
config::ApplicationSettings,
|
||
};
|
||
|
||
pub type MessageFetchResult = IambResult<(Option<String>, Vec<RoomMessageEvent>)>;
|
||
pub type MessageKey = (MessageTimeStamp, OwnedEventId);
|
||
pub type Messages = BTreeMap<MessageKey, Message>;
|
||
|
||
const USER_GUTTER: usize = 30;
|
||
const TIME_GUTTER: usize = 12;
|
||
const MIN_MSG_LEN: usize = 30;
|
||
|
||
const USER_GUTTER_EMPTY: &str = " ";
|
||
const USER_GUTTER_EMPTY_SPAN: Span<'static> = Span {
|
||
content: Cow::Borrowed(USER_GUTTER_EMPTY),
|
||
style: Style {
|
||
fg: None,
|
||
bg: None,
|
||
add_modifier: StyleModifier::empty(),
|
||
sub_modifier: StyleModifier::empty(),
|
||
},
|
||
};
|
||
|
||
struct WrappedLinesIterator<'a> {
|
||
iter: Lines<'a>,
|
||
curr: Option<&'a str>,
|
||
width: usize,
|
||
}
|
||
|
||
impl<'a> WrappedLinesIterator<'a> {
|
||
fn new(input: &'a str, width: usize) -> Self {
|
||
WrappedLinesIterator { iter: input.lines(), curr: None, width }
|
||
}
|
||
}
|
||
|
||
impl<'a> Iterator for WrappedLinesIterator<'a> {
|
||
type Item = (&'a str, usize);
|
||
|
||
fn next(&mut self) -> Option<Self::Item> {
|
||
if self.curr.is_none() {
|
||
self.curr = self.iter.next();
|
||
}
|
||
|
||
if let Some(s) = self.curr.take() {
|
||
let width = UnicodeWidthStr::width(s);
|
||
|
||
if width <= self.width {
|
||
return Some((s, width));
|
||
} else {
|
||
// Find where to split the line.
|
||
let mut width = 0;
|
||
let mut idx = 0;
|
||
|
||
for (i, g) in UnicodeSegmentation::grapheme_indices(s, true) {
|
||
let gw = UnicodeWidthStr::width(g);
|
||
idx = i;
|
||
|
||
if width + gw > self.width {
|
||
break;
|
||
}
|
||
|
||
width += gw;
|
||
}
|
||
|
||
self.curr = Some(&s[idx..]);
|
||
|
||
return Some((&s[..idx], width));
|
||
}
|
||
} else {
|
||
return None;
|
||
}
|
||
}
|
||
}
|
||
|
||
fn wrap(input: &str, width: usize) -> WrappedLinesIterator<'_> {
|
||
WrappedLinesIterator::new(input, width)
|
||
}
|
||
|
||
fn space(width: usize) -> String {
|
||
" ".repeat(width)
|
||
}
|
||
|
||
#[derive(thiserror::Error, Debug)]
|
||
pub enum TimeStampIntError {
|
||
#[error("Integer conversion error: {0}")]
|
||
IntError(#[from] std::num::TryFromIntError),
|
||
|
||
#[error("UInt conversion error: {0}")]
|
||
UIntError(<UInt as TryFrom<u64>>::Error),
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||
pub enum MessageTimeStamp {
|
||
OriginServer(UInt),
|
||
LocalEcho,
|
||
}
|
||
|
||
impl MessageTimeStamp {
|
||
fn show(&self) -> Option<Span> {
|
||
match self {
|
||
MessageTimeStamp::OriginServer(ts) => {
|
||
let time = i64::from(*ts) / 1000;
|
||
let time = NaiveDateTime::from_timestamp_opt(time, 0)?;
|
||
let time = DateTime::<Utc>::from_utc(time, Utc);
|
||
let time = time.format("%T");
|
||
let time = format!(" [{}]", time);
|
||
|
||
Span::raw(time).into()
|
||
},
|
||
MessageTimeStamp::LocalEcho => None,
|
||
}
|
||
}
|
||
|
||
fn is_local_echo(&self) -> bool {
|
||
matches!(self, MessageTimeStamp::LocalEcho)
|
||
}
|
||
|
||
pub fn as_millis(&self) -> Option<MilliSecondsSinceUnixEpoch> {
|
||
match self {
|
||
MessageTimeStamp::OriginServer(ms) => MilliSecondsSinceUnixEpoch(*ms).into(),
|
||
MessageTimeStamp::LocalEcho => None,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Ord for MessageTimeStamp {
|
||
fn cmp(&self, other: &Self) -> Ordering {
|
||
match (self, other) {
|
||
(MessageTimeStamp::OriginServer(_), MessageTimeStamp::LocalEcho) => Ordering::Less,
|
||
(MessageTimeStamp::OriginServer(a), MessageTimeStamp::OriginServer(b)) => a.cmp(b),
|
||
(MessageTimeStamp::LocalEcho, MessageTimeStamp::OriginServer(_)) => Ordering::Greater,
|
||
(MessageTimeStamp::LocalEcho, MessageTimeStamp::LocalEcho) => Ordering::Equal,
|
||
}
|
||
}
|
||
}
|
||
|
||
impl PartialOrd for MessageTimeStamp {
|
||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||
self.cmp(other).into()
|
||
}
|
||
}
|
||
|
||
impl From<MilliSecondsSinceUnixEpoch> for MessageTimeStamp {
|
||
fn from(millis: MilliSecondsSinceUnixEpoch) -> Self {
|
||
MessageTimeStamp::OriginServer(millis.0)
|
||
}
|
||
}
|
||
|
||
impl TryFrom<&MessageTimeStamp> for usize {
|
||
type Error = TimeStampIntError;
|
||
|
||
fn try_from(ts: &MessageTimeStamp) -> Result<Self, Self::Error> {
|
||
let n = match ts {
|
||
MessageTimeStamp::LocalEcho => 0,
|
||
MessageTimeStamp::OriginServer(u) => usize::try_from(u64::from(*u))?,
|
||
};
|
||
|
||
Ok(n)
|
||
}
|
||
}
|
||
|
||
impl TryFrom<usize> for MessageTimeStamp {
|
||
type Error = TimeStampIntError;
|
||
|
||
fn try_from(u: usize) -> Result<Self, Self::Error> {
|
||
if u == 0 {
|
||
Ok(MessageTimeStamp::LocalEcho)
|
||
} else {
|
||
let n = u64::try_from(u)?;
|
||
let n = UInt::try_from(n).map_err(TimeStampIntError::UIntError)?;
|
||
|
||
Ok(MessageTimeStamp::OriginServer(n))
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||
pub struct MessageCursor {
|
||
/// When timestamp is None, the corner is determined by moving backwards from
|
||
/// the most recently received message.
|
||
pub timestamp: Option<MessageKey>,
|
||
|
||
/// A row within the [Text] representation of a [Message].
|
||
pub text_row: usize,
|
||
}
|
||
|
||
impl MessageCursor {
|
||
pub fn new(timestamp: MessageKey, text_row: usize) -> Self {
|
||
MessageCursor { timestamp: Some(timestamp), text_row }
|
||
}
|
||
|
||
/// Get a cursor that refers to the most recent message.
|
||
pub fn latest() -> Self {
|
||
MessageCursor::default()
|
||
}
|
||
|
||
pub fn to_key<'a>(&'a self, info: &'a RoomInfo) -> Option<&'a MessageKey> {
|
||
if let Some(ref key) = self.timestamp {
|
||
Some(key)
|
||
} else {
|
||
Some(info.messages.last_key_value()?.0)
|
||
}
|
||
}
|
||
|
||
pub fn from_cursor(cursor: &Cursor, info: &RoomInfo) -> Option<Self> {
|
||
let ev_hash = u64::try_from(cursor.get_x()).ok()?;
|
||
let ev_term = OwnedEventId::try_from("$").ok()?;
|
||
|
||
let ts_start = MessageTimeStamp::try_from(cursor.get_y()).ok()?;
|
||
let start = (ts_start, ev_term);
|
||
let mut mc = None;
|
||
|
||
for ((ts, event_id), _) in info.messages.range(start..) {
|
||
let mut hasher = DefaultHasher::new();
|
||
event_id.hash(&mut hasher);
|
||
|
||
if hasher.finish() == ev_hash {
|
||
mc = Self::from((*ts, event_id.clone())).into();
|
||
break;
|
||
}
|
||
|
||
if mc.is_none() {
|
||
mc = Self::from((*ts, event_id.clone())).into();
|
||
}
|
||
|
||
if ts > &ts_start {
|
||
break;
|
||
}
|
||
}
|
||
|
||
return mc;
|
||
}
|
||
|
||
pub fn to_cursor(&self, info: &RoomInfo) -> Option<Cursor> {
|
||
let (ts, event_id) = self.to_key(info)?;
|
||
|
||
let y: usize = usize::try_from(ts).ok()?;
|
||
|
||
let mut hasher = DefaultHasher::new();
|
||
event_id.hash(&mut hasher);
|
||
let x = usize::try_from(hasher.finish()).ok()?;
|
||
|
||
Cursor::new(y, x).into()
|
||
}
|
||
}
|
||
|
||
impl From<Option<MessageKey>> for MessageCursor {
|
||
fn from(key: Option<MessageKey>) -> Self {
|
||
MessageCursor { timestamp: key, text_row: 0 }
|
||
}
|
||
}
|
||
|
||
impl From<MessageKey> for MessageCursor {
|
||
fn from(key: MessageKey) -> Self {
|
||
MessageCursor { timestamp: Some(key), text_row: 0 }
|
||
}
|
||
}
|
||
|
||
impl Ord for MessageCursor {
|
||
fn cmp(&self, other: &Self) -> Ordering {
|
||
match (&self.timestamp, &other.timestamp) {
|
||
(None, None) => self.text_row.cmp(&other.text_row),
|
||
(None, Some(_)) => Ordering::Greater,
|
||
(Some(_), None) => Ordering::Less,
|
||
(Some(st), Some(ot)) => {
|
||
let pcmp = st.cmp(ot);
|
||
let tcmp = self.text_row.cmp(&other.text_row);
|
||
|
||
pcmp.then(tcmp)
|
||
},
|
||
}
|
||
}
|
||
}
|
||
|
||
impl PartialOrd for MessageCursor {
|
||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||
self.cmp(other).into()
|
||
}
|
||
}
|
||
|
||
#[derive(Clone)]
|
||
pub enum MessageEvent {
|
||
Original(Box<OriginalRoomMessageEvent>),
|
||
Redacted(Box<RedactedRoomMessageEvent>),
|
||
Local(Box<RoomMessageEventContent>),
|
||
}
|
||
|
||
impl MessageEvent {
|
||
pub fn show(&self) -> Cow<'_, str> {
|
||
match self {
|
||
MessageEvent::Original(ev) => show_room_content(&ev.content),
|
||
MessageEvent::Redacted(_) => Cow::Borrowed("[redacted]"),
|
||
MessageEvent::Local(content) => show_room_content(content),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn show_room_content(content: &RoomMessageEventContent) -> Cow<'_, str> {
|
||
let s = match &content.msgtype {
|
||
MessageType::Text(content) => content.body.as_ref(),
|
||
MessageType::Emote(content) => content.body.as_ref(),
|
||
MessageType::Notice(content) => content.body.as_str(),
|
||
MessageType::ServerNotice(content) => content.body.as_str(),
|
||
|
||
MessageType::VerificationRequest(_) => {
|
||
// XXX: implement
|
||
|
||
return Cow::Owned("[verification request]".into());
|
||
},
|
||
MessageType::Audio(content) => {
|
||
return Cow::Owned(format!("[Attached Audio: {}]", content.body));
|
||
},
|
||
MessageType::File(content) => {
|
||
return Cow::Owned(format!("[Attached File: {}]", content.body));
|
||
},
|
||
MessageType::Image(content) => {
|
||
return Cow::Owned(format!("[Attached Image: {}]", content.body));
|
||
},
|
||
MessageType::Video(content) => {
|
||
return Cow::Owned(format!("[Attached Video: {}]", content.body));
|
||
},
|
||
_ => {
|
||
return Cow::Owned(format!("[Unknown message type: {:?}]", content.msgtype()));
|
||
},
|
||
};
|
||
|
||
Cow::Borrowed(s)
|
||
}
|
||
|
||
#[derive(Clone)]
|
||
pub struct Message {
|
||
pub event: MessageEvent,
|
||
pub sender: OwnedUserId,
|
||
pub timestamp: MessageTimeStamp,
|
||
pub downloaded: bool,
|
||
}
|
||
|
||
impl Message {
|
||
pub fn new(event: MessageEvent, sender: OwnedUserId, timestamp: MessageTimeStamp) -> Self {
|
||
Message { event, sender, timestamp, downloaded: false }
|
||
}
|
||
|
||
pub fn show(
|
||
&self,
|
||
prev: Option<&Message>,
|
||
selected: bool,
|
||
vwctx: &ViewportContext<MessageCursor>,
|
||
settings: &ApplicationSettings,
|
||
) -> Text {
|
||
let width = vwctx.get_width();
|
||
let mut msg = self.event.show();
|
||
|
||
if self.downloaded {
|
||
msg.to_mut().push_str(" \u{2705}");
|
||
}
|
||
|
||
let msg = msg.as_ref();
|
||
|
||
let mut lines = vec![];
|
||
|
||
let mut style = Style::default();
|
||
|
||
if selected {
|
||
style = style.add_modifier(StyleModifier::REVERSED)
|
||
}
|
||
|
||
if self.timestamp.is_local_echo() {
|
||
style = style.add_modifier(StyleModifier::ITALIC);
|
||
}
|
||
|
||
if USER_GUTTER + TIME_GUTTER + MIN_MSG_LEN <= width {
|
||
let lw = width - USER_GUTTER - TIME_GUTTER;
|
||
|
||
for (i, (line, w)) in wrap(msg, lw).enumerate() {
|
||
let line = Span::styled(line.to_string(), style);
|
||
let trailing = Span::styled(space(lw.saturating_sub(w)), style);
|
||
|
||
if i == 0 {
|
||
let user = self.show_sender(prev, true, settings);
|
||
|
||
if let Some(time) = self.timestamp.show() {
|
||
lines.push(Spans(vec![user, line, trailing, time]))
|
||
} else {
|
||
lines.push(Spans(vec![user, line, trailing]))
|
||
}
|
||
} else {
|
||
let space = USER_GUTTER_EMPTY_SPAN;
|
||
|
||
lines.push(Spans(vec![space, line, trailing]))
|
||
}
|
||
}
|
||
} else if USER_GUTTER + MIN_MSG_LEN <= width {
|
||
let lw = width - USER_GUTTER;
|
||
|
||
for (i, (line, w)) in wrap(msg, lw).enumerate() {
|
||
let line = Span::styled(line.to_string(), style);
|
||
let trailing = Span::styled(space(lw.saturating_sub(w)), style);
|
||
|
||
let prefix = if i == 0 {
|
||
self.show_sender(prev, true, settings)
|
||
} else {
|
||
USER_GUTTER_EMPTY_SPAN
|
||
};
|
||
|
||
lines.push(Spans(vec![prefix, line, trailing]))
|
||
}
|
||
} else {
|
||
lines.push(Spans::from(self.show_sender(prev, false, settings)));
|
||
|
||
for (line, _) in wrap(msg, width.saturating_sub(2)) {
|
||
let line = format!(" {}", line);
|
||
let line = Span::styled(line, style);
|
||
|
||
lines.push(Spans(vec![line]))
|
||
}
|
||
}
|
||
|
||
return Text { lines };
|
||
}
|
||
|
||
fn show_sender(
|
||
&self,
|
||
prev: Option<&Message>,
|
||
align_right: bool,
|
||
settings: &ApplicationSettings,
|
||
) -> Span {
|
||
let user = if matches!(prev, Some(prev) if self.sender == prev.sender) {
|
||
USER_GUTTER_EMPTY_SPAN
|
||
} else {
|
||
settings.get_user_span(self.sender.as_ref())
|
||
};
|
||
|
||
let Span { content, style } = user;
|
||
let stop = content.len().min(28);
|
||
let s = &content[..stop];
|
||
|
||
let sender = if align_right {
|
||
format!("{: >width$} ", s, width = 28)
|
||
} else {
|
||
format!("{: <width$} ", s, width = 28)
|
||
};
|
||
|
||
Span::styled(sender, style)
|
||
}
|
||
}
|
||
|
||
impl From<OriginalRoomMessageEvent> for Message {
|
||
fn from(event: OriginalRoomMessageEvent) -> Self {
|
||
let timestamp = event.origin_server_ts.into();
|
||
let user_id = event.sender.clone();
|
||
let content = MessageEvent::Original(event.into());
|
||
|
||
Message::new(content, user_id, timestamp)
|
||
}
|
||
}
|
||
|
||
impl From<RedactedRoomMessageEvent> for Message {
|
||
fn from(event: RedactedRoomMessageEvent) -> Self {
|
||
let timestamp = event.origin_server_ts.into();
|
||
let user_id = event.sender.clone();
|
||
let content = MessageEvent::Redacted(event.into());
|
||
|
||
Message::new(content, user_id, timestamp)
|
||
}
|
||
}
|
||
|
||
impl From<RoomMessageEvent> for Message {
|
||
fn from(event: RoomMessageEvent) -> Self {
|
||
match event {
|
||
RoomMessageEvent::Original(ev) => ev.into(),
|
||
RoomMessageEvent::Redacted(ev) => ev.into(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl ToString for Message {
|
||
fn to_string(&self) -> String {
|
||
self.event.show().into_owned()
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
pub mod tests {
|
||
use super::*;
|
||
use crate::tests::*;
|
||
|
||
#[test]
|
||
fn test_wrapped_lines_ascii() {
|
||
let s = "hello world!\nabcdefghijklmnopqrstuvwxyz\ngoodbye";
|
||
|
||
let mut iter = wrap(s, 100);
|
||
assert_eq!(iter.next(), Some(("hello world!", 12)));
|
||
assert_eq!(iter.next(), Some(("abcdefghijklmnopqrstuvwxyz", 26)));
|
||
assert_eq!(iter.next(), Some(("goodbye", 7)));
|
||
assert_eq!(iter.next(), None);
|
||
|
||
let mut iter = wrap(s, 5);
|
||
assert_eq!(iter.next(), Some(("hello", 5)));
|
||
assert_eq!(iter.next(), Some((" worl", 5)));
|
||
assert_eq!(iter.next(), Some(("d!", 2)));
|
||
assert_eq!(iter.next(), Some(("abcde", 5)));
|
||
assert_eq!(iter.next(), Some(("fghij", 5)));
|
||
assert_eq!(iter.next(), Some(("klmno", 5)));
|
||
assert_eq!(iter.next(), Some(("pqrst", 5)));
|
||
assert_eq!(iter.next(), Some(("uvwxy", 5)));
|
||
assert_eq!(iter.next(), Some(("z", 1)));
|
||
assert_eq!(iter.next(), Some(("goodb", 5)));
|
||
assert_eq!(iter.next(), Some(("ye", 2)));
|
||
assert_eq!(iter.next(), None);
|
||
}
|
||
|
||
#[test]
|
||
fn test_wrapped_lines_unicode() {
|
||
let s = "ＣＨＩＣＫＥＮ";
|
||
|
||
let mut iter = wrap(s, 14);
|
||
assert_eq!(iter.next(), Some((s, 14)));
|
||
assert_eq!(iter.next(), None);
|
||
|
||
let mut iter = wrap(s, 5);
|
||
assert_eq!(iter.next(), Some(("ＣＨ", 4)));
|
||
assert_eq!(iter.next(), Some(("ＩＣ", 4)));
|
||
assert_eq!(iter.next(), Some(("ＫＥ", 4)));
|
||
assert_eq!(iter.next(), Some(("Ｎ", 2)));
|
||
assert_eq!(iter.next(), None);
|
||
}
|
||
|
||
#[test]
|
||
fn test_mc_cmp() {
|
||
let mc1 = MessageCursor::from(MSG1_KEY.clone());
|
||
let mc2 = MessageCursor::from(MSG2_KEY.clone());
|
||
let mc3 = MessageCursor::from(MSG3_KEY.clone());
|
||
let mc4 = MessageCursor::from(MSG4_KEY.clone());
|
||
let mc5 = MessageCursor::from(MSG5_KEY.clone());
|
||
|
||
// Everything is equal to itself.
|
||
assert_eq!(mc1.cmp(&mc1), Ordering::Equal);
|
||
assert_eq!(mc2.cmp(&mc2), Ordering::Equal);
|
||
assert_eq!(mc3.cmp(&mc3), Ordering::Equal);
|
||
assert_eq!(mc4.cmp(&mc4), Ordering::Equal);
|
||
assert_eq!(mc5.cmp(&mc5), Ordering::Equal);
|
||
|
||
// Local echo is always greater than an origin server timestamp.
|
||
assert_eq!(mc1.cmp(&mc2), Ordering::Greater);
|
||
assert_eq!(mc1.cmp(&mc3), Ordering::Greater);
|
||
assert_eq!(mc1.cmp(&mc4), Ordering::Greater);
|
||
assert_eq!(mc1.cmp(&mc5), Ordering::Greater);
|
||
|
||
// mc2 is the smallest timestamp.
|
||
assert_eq!(mc2.cmp(&mc1), Ordering::Less);
|
||
assert_eq!(mc2.cmp(&mc3), Ordering::Less);
|
||
assert_eq!(mc2.cmp(&mc4), Ordering::Less);
|
||
assert_eq!(mc2.cmp(&mc5), Ordering::Less);
|
||
|
||
// mc3 should be less than mc4 because of its event ID.
|
||
assert_eq!(mc3.cmp(&mc1), Ordering::Less);
|
||
assert_eq!(mc3.cmp(&mc2), Ordering::Greater);
|
||
assert_eq!(mc3.cmp(&mc4), Ordering::Less);
|
||
assert_eq!(mc3.cmp(&mc5), Ordering::Less);
|
||
|
||
// mc4 should be greater than mc3 because of its event ID.
|
||
assert_eq!(mc4.cmp(&mc1), Ordering::Less);
|
||
assert_eq!(mc4.cmp(&mc2), Ordering::Greater);
|
||
assert_eq!(mc4.cmp(&mc3), Ordering::Greater);
|
||
assert_eq!(mc4.cmp(&mc5), Ordering::Less);
|
||
|
||
// mc5 is the greatest OriginServer timestamp.
|
||
assert_eq!(mc5.cmp(&mc1), Ordering::Less);
|
||
assert_eq!(mc5.cmp(&mc2), Ordering::Greater);
|
||
assert_eq!(mc5.cmp(&mc3), Ordering::Greater);
|
||
assert_eq!(mc5.cmp(&mc4), Ordering::Greater);
|
||
}
|
||
|
||
#[test]
|
||
fn test_mc_to_key() {
|
||
let info = mock_room();
|
||
let mc1 = MessageCursor::from(MSG1_KEY.clone());
|
||
let mc2 = MessageCursor::from(MSG2_KEY.clone());
|
||
let mc3 = MessageCursor::from(MSG3_KEY.clone());
|
||
let mc4 = MessageCursor::from(MSG4_KEY.clone());
|
||
let mc5 = MessageCursor::from(MSG5_KEY.clone());
|
||
let mc6 = MessageCursor::latest();
|
||
|
||
let k1 = mc1.to_key(&info).unwrap();
|
||
let k2 = mc2.to_key(&info).unwrap();
|
||
let k3 = mc3.to_key(&info).unwrap();
|
||
let k4 = mc4.to_key(&info).unwrap();
|
||
let k5 = mc5.to_key(&info).unwrap();
|
||
let k6 = mc6.to_key(&info).unwrap();
|
||
|
||
// These should all be equal to their MSGN_KEYs.
|
||
assert_eq!(k1, &MSG1_KEY.clone());
|
||
assert_eq!(k2, &MSG2_KEY.clone());
|
||
assert_eq!(k3, &MSG3_KEY.clone());
|
||
assert_eq!(k4, &MSG4_KEY.clone());
|
||
assert_eq!(k5, &MSG5_KEY.clone());
|
||
|
||
// MessageCursor::latest() turns into the largest key (our local echo message).
|
||
assert_eq!(k6, &MSG1_KEY.clone());
|
||
|
||
// MessageCursor::latest() fails to convert for a room w/o messages.
|
||
let info_empty = RoomInfo::default();
|
||
assert_eq!(mc6.to_key(&info_empty), None);
|
||
}
|
||
|
||
#[test]
|
||
fn test_mc_to_from_cursor() {
|
||
let info = mock_room();
|
||
let mc1 = MessageCursor::from(MSG1_KEY.clone());
|
||
let mc2 = MessageCursor::from(MSG2_KEY.clone());
|
||
let mc3 = MessageCursor::from(MSG3_KEY.clone());
|
||
let mc4 = MessageCursor::from(MSG4_KEY.clone());
|
||
let mc5 = MessageCursor::from(MSG5_KEY.clone());
|
||
let mc6 = MessageCursor::latest();
|
||
|
||
let identity = |mc: &MessageCursor| {
|
||
let c = mc.to_cursor(&info).unwrap();
|
||
|
||
MessageCursor::from_cursor(&c, &info).unwrap()
|
||
};
|
||
|
||
// These should all convert to a Cursor and back to the original value.
|
||
assert_eq!(identity(&mc1), mc1);
|
||
assert_eq!(identity(&mc2), mc2);
|
||
assert_eq!(identity(&mc3), mc3);
|
||
assert_eq!(identity(&mc4), mc4);
|
||
assert_eq!(identity(&mc5), mc5);
|
||
|
||
// MessageCursor::latest() should point at the most recent message after conversion.
|
||
assert_eq!(identity(&mc6), mc1);
|
||
}
|
||
}
|