paperos 0.2.0

A programmable editor built on the Runact actor runtime
Documentation
use std::collections::VecDeque;
use std::sync::{Arc, RwLock};

/// Shared, bounded message queue for editor status/echo messages.
///
/// Clone shares the underlying queue, so the render extension and any
/// producer (command handlers, the runtime) can all feed one echo line.
#[derive(Clone)]
pub struct MessageSink {
    inner: Arc<RwLock<VecDeque<String>>>,
    max_len: usize,
}

#[allow(dead_code)]
impl MessageSink {
    pub fn new(max_len: usize) -> Self {
        Self {
            inner: Arc::new(RwLock::new(VecDeque::new())),
            max_len: max_len.max(1),
        }
    }

    /// Append a message, evicting the oldest when over capacity.
    pub fn push(&self, msg: impl Into<String>) {
        let mut queue = self.inner.write().unwrap();
        if queue.len() >= self.max_len {
            queue.pop_front();
        }
        queue.push_back(msg.into());
    }

    pub fn last(&self) -> Option<String> {
        self.inner.read().unwrap().back().cloned()
    }

    pub fn len(&self) -> usize {
        self.inner.read().unwrap().len()
    }

    pub fn is_empty(&self) -> bool {
        self.inner.read().unwrap().is_empty()
    }

    pub fn clear(&self) {
        self.inner.write().unwrap().clear();
    }
}

impl Default for MessageSink {
    fn default() -> Self {
        Self::new(100)
    }
}

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

    #[test]
    fn push_then_last_returns_newest() {
        let sink = MessageSink::new(4);
        sink.push("a");
        sink.push("b");
        assert_eq!(sink.last(), Some("b".to_string()));
        assert_eq!(sink.len(), 2);
    }

    #[test]
    fn bounded_queue_evicts_oldest() {
        let sink = MessageSink::new(2);
        sink.push("1");
        sink.push("2");
        sink.push("3");
        assert_eq!(sink.len(), 2);
        assert_eq!(sink.last(), Some("3".to_string()));
    }

    #[test]
    fn empty_sink_returns_none() {
        let sink = MessageSink::new(5);
        assert_eq!(sink.last(), None);
        assert!(sink.is_empty());
    }

    #[test]
    fn clear_empties_queue() {
        let sink = MessageSink::new(5);
        sink.push("x");
        sink.clear();
        assert!(sink.is_empty());
    }
}