Add RawMessage support to the line renderer.

Author: stuhood

src/messages.rs

@@ -26,10 +26,31 @@ pub struct Message {
     pub message: String,
 }
 
+impl Message {
+    /// Create a new Message at the current time, with the given arguments.
+    pub fn new(level: MessageLevel, origin: String, message: impl Into<String>) -> Self {
+        Message {
+            time: SystemTime::now(),
+            level,
+            origin,
+            message: message.into(),
+        }
+    }
+}
+
+/// A container for multiple message types.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Envelope {
+    /// A high level string message and its metadata.
+    Message(Message),
+    /// A single-line, raw message, with no metadata.
+    RawMessage(String),
+}
+
 /// A ring buffer for messages.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct MessageRingBuffer {
-    pub(crate) buf: Vec<Message>,
+    pub(crate) buf: Vec<Envelope>,
     cursor: usize,
     total: usize,
 }
@@ -44,25 +65,19 @@ impl MessageRingBuffer {
         }
     }
 
-    /// Push a `message` from `origin` at severity `level` into the buffer, possibly overwriting the last message added.
-    pub fn push_overwrite(&mut self, level: MessageLevel, origin: String, message: impl Into<String>) {
-        let msg = Message {
-            time: SystemTime::now(),
-            level,
-            origin,
-            message: message.into(),
-        };
+    /// Push a `message` into the buffer, possibly overwriting the last message added.
+    pub fn push_overwrite(&mut self, message: Envelope) {
         if self.has_capacity() {
-            self.buf.push(msg)
+            self.buf.push(message)
         } else {
-            self.buf[self.cursor] = msg;
+            self.buf[self.cursor] = message;
             self.cursor = (self.cursor + 1) % self.buf.len();
         }
         self.total = self.total.wrapping_add(1);
     }
 
     /// Copy all messages currently contained in the buffer to `out`.
-    pub fn copy_all(&self, out: &mut Vec<Message>) {
+    pub fn copy_all(&self, out: &mut Vec<Envelope>) {
         out.clear();
         if self.buf.is_empty() {
             return;
@@ -75,7 +90,7 @@ impl MessageRingBuffer {
 
     /// Copy all new messages into `out` that where received since the last time this method was called provided
     /// its `previous` return value.
-    pub fn copy_new(&self, out: &mut Vec<Message>, previous: Option<MessageCopyState>) -> MessageCopyState {
+    pub fn copy_new(&self, out: &mut Vec<Envelope>, previous: Option<MessageCopyState>) -> MessageCopyState {
         out.clear();
         match previous {
             Some(MessageCopyState { cursor, buf_len, total }) => {

src/render/line/draw.rs

@@ -1,5 +1,5 @@
 use crate::{
-    messages::{Message, MessageCopyState, MessageLevel},
+    messages::{Envelope, Message, MessageCopyState, MessageLevel},
     progress::{self, Value},
     unit, Root, Throughput,
 };
@@ -13,7 +13,7 @@ use unicode_width::UnicodeWidthStr;
 #[derive(Default)]
 pub struct State {
     tree: Vec<(progress::Key, progress::Task)>,
-    messages: Vec<Message>,
+    messages: Vec<Envelope>,
     for_next_copy: Option<MessageCopyState>,
     /// The size of the message origin, tracking the terminal height so things potentially off screen don't influence width anymore.
     message_origin_size: VecDeque<usize>,
@@ -52,47 +52,57 @@ fn messages(
     }
     let mut tokens: Vec<ANSIString<'_>> = Vec::with_capacity(6);
     let mut current_maximum = state.message_origin_size.iter().max().cloned().unwrap_or(0);
-    for Message {
-        time,
-        level,
-        origin,
-        message,
-    } in &state.messages
-    {
+    for envelope in &state.messages {
         tokens.clear();
         let blocks_drawn_during_previous_tick = state.blocks_per_line.pop_front().unwrap_or(0);
-        let message_block_len = origin.width();
-        current_maximum = current_maximum.max(message_block_len);
-        if state.message_origin_size.len() == max_height {
-            state.message_origin_size.pop_front();
-        }
-        state.message_origin_size.push_back(message_block_len);
 
-        let color = to_color(*level);
-        tokens.push(" ".into());
-        if timestamp {
-            tokens.push(
-                brush
-                    .style(color.dimmed().on(Color::Yellow))
-                    .paint(crate::time::format_time_for_messages(*time)),
-            );
-            tokens.push(Style::default().paint(" "));
-        } else {
-            tokens.push("".into());
+        match envelope {
+            Envelope::RawMessage(content) => {
+                // RawMessages have already been split into single lines without newlines appended,
+                // and so can be rendered directly as ANSIStrings.
+                tokens.push(ANSIString::from(content))
+            }
+            Envelope::Message(Message {
+                time,
+                level,
+                origin,
+                message,
+            }) => {
+                let message_block_len = origin.width();
+                current_maximum = current_maximum.max(message_block_len);
+                if state.message_origin_size.len() == max_height {
+                    state.message_origin_size.pop_front();
+                }
+                state.message_origin_size.push_back(message_block_len);
+
+                let color = to_color(*level);
+                tokens.push(" ".into());
+                if timestamp {
+                    tokens.push(
+                        brush
+                            .style(color.dimmed().on(Color::Yellow))
+                            .paint(crate::time::format_time_for_messages(*time)),
+                    );
+                    tokens.push(Style::default().paint(" "));
+                } else {
+                    tokens.push("".into());
+                };
+                tokens.push(brush.style(Style::default().dimmed()).paint(format!(
+                    "{:>fill_size$}{}",
+                    "",
+                    origin,
+                    fill_size = current_maximum - message_block_len,
+                )));
+                tokens.push(" ".into());
+                tokens.push(brush.style(color.bold()).paint(message));
+            }
         };
-        tokens.push(brush.style(Style::default().dimmed()).paint(format!(
-            "{:>fill_size$}{}",
-            "",
-            origin,
-            fill_size = current_maximum - message_block_len,
-        )));
-        tokens.push(" ".into());
-        tokens.push(brush.style(color.bold()).paint(message));
+
         let message_block_count = block_count_sans_ansi_codes(&tokens);
         write!(out, "{}", ANSIStrings(tokens.as_slice()))?;
 
         if blocks_drawn_during_previous_tick > message_block_count {
-            newline_with_overdraw(out, &tokens, blocks_drawn_during_previous_tick)?;
+            newline_with_overdraw(out, message_block_count, blocks_drawn_during_previous_tick)?;
         } else {
             writeln!(out)?;
         }
@@ -161,7 +171,8 @@ pub fn all(
             );
             write!(out, "{}", ANSIStrings(tokens.as_slice()))?;
 
-            **blocks_in_last_iteration = newline_with_overdraw(out, &tokens, **blocks_in_last_iteration)?;
+            **blocks_in_last_iteration =
+                newline_with_overdraw(out, block_count_sans_ansi_codes(&tokens), **blocks_in_last_iteration)?;
         }
         if let Some(tp) = state.throughput.as_mut() {
             tp.reconcile(&state.tree);
@@ -186,10 +197,9 @@ pub fn all(
 /// Must be called directly after `tokens` were drawn, without newline. Takes care of adding the newline.
 fn newline_with_overdraw(
     out: &mut impl io::Write,
-    tokens: &[ANSIString<'_>],
+    current_block_count: u16,
     blocks_in_last_iteration: u16,
 ) -> io::Result<u16> {
-    let current_block_count = block_count_sans_ansi_codes(tokens);
     if blocks_in_last_iteration > current_block_count {
         // fill to the end of line to overwrite what was previously there
         writeln!(

src/traits.rs

@@ -65,7 +65,7 @@ pub trait Progress: Send + 'static {
 
     /// Create a `message` of the given `level` and store it with the progress tree.
     ///
-    /// Use this to provide additional,human-readable information about the progress
+    /// Use this to provide additional, human-readable information about the progress
     /// made, including indicating success or failure.
     fn message(&mut self, level: MessageLevel, message: impl Into<String>);
 
@@ -126,7 +126,7 @@ pub trait Progress: Send + 'static {
     }
 }
 
-use crate::messages::{Message, MessageCopyState};
+use crate::messages::{Envelope, MessageCopyState};
 
 /// The top level of a progress task hiearchy, with `progress::Task`s identified with `progress::Key`s
 pub trait Root {
@@ -142,11 +142,16 @@ pub trait Root {
     /// The `out` vec will be cleared automatically.
     fn sorted_snapshot(&self, out: &mut Vec<(progress::Key, progress::Task)>);
 
+    /// Create a raw `message` and store it with the progress tree.
+    ///
+    /// Use this to render additional unclassified output about the progress made.
+    fn message_raw(&mut self, message: impl Into<String>);
+
     /// Copy all messages from the internal ring buffer into the given `out`
     /// vector. Messages are ordered from oldest to newest.
-    fn copy_messages(&self, out: &mut Vec<Message>);
+    fn copy_messages(&self, out: &mut Vec<Envelope>);
 
     /// Copy only new messages from the internal ring buffer into the given `out`
     /// vector. Messages are ordered from oldest to newest.
-    fn copy_new_messages(&self, out: &mut Vec<Message>, prev: Option<MessageCopyState>) -> MessageCopyState;
+    fn copy_new_messages(&self, out: &mut Vec<Envelope>, prev: Option<MessageCopyState>) -> MessageCopyState;
 }

src/tree/item.rs

@@ -1,5 +1,5 @@
 use crate::{
-    messages::{MessageLevel, MessageRingBuffer},
+    messages::{Envelope, Message, MessageLevel, MessageRingBuffer},
     progress::{key, Key, State, Step, Task, Value},
     unit::Unit,
 };
@@ -189,7 +189,7 @@ impl Item {
     /// made, including indicating success or failure.
     pub fn message(&mut self, level: MessageLevel, message: impl Into<String>) {
         let message: String = message.into();
-        self.messages.lock().push_overwrite(
+        self.messages.lock().push_overwrite(Envelope::Message(Message::new(
             level,
             {
                 let name = self.tree.get(&self.key).map(|v| v.name.to_owned()).unwrap_or_default();
@@ -203,7 +203,7 @@ impl Item {
                 name
             },
             message,
-        )
+        )))
     }
 
     /// Create a message indicating the task is done

src/tree/root.rs

@@ -1,5 +1,5 @@
 use crate::{
-    messages::{Message, MessageCopyState, MessageRingBuffer},
+    messages::{Envelope, MessageCopyState, MessageRingBuffer},
     progress::{Key, Task},
     tree::Item,
 };
@@ -55,15 +55,26 @@ impl Root {
         out.sort_by_key(|t| t.0);
     }
 
+    /// Create a raw `message` and store it with the progress tree.
+    ///
+    /// Use this to render additional unclassified output about the progress made.
+    fn message_raw(&mut self, message: impl Into<String>) {
+        let inner = self.inner.lock();
+        let mut messages = inner.messages.lock();
+        for line in message.into().lines() {
+            messages.push_overwrite(Envelope::RawMessage(line.trim_end().to_owned()));
+        }
+    }
+
     /// Copy all messages from the internal ring buffer into the given `out`
     /// vector. Messages are ordered from oldest to newest.
-    pub fn copy_messages(&self, out: &mut Vec<Message>) {
+    pub fn copy_messages(&self, out: &mut Vec<Envelope>) {
         self.inner.lock().messages.lock().copy_all(out);
     }
 
     /// Copy only new messages from the internal ring buffer into the given `out`
     /// vector. Messages are ordered from oldest to newest.
-    pub fn copy_new_messages(&self, out: &mut Vec<Message>, prev: Option<MessageCopyState>) -> MessageCopyState {
+    pub fn copy_new_messages(&self, out: &mut Vec<Envelope>, prev: Option<MessageCopyState>) -> MessageCopyState {
         self.inner.lock().messages.lock().copy_new(out, prev)
     }
 
@@ -139,11 +150,15 @@ impl crate::Root for Root {
         self.sorted_snapshot(out)
     }
 
-    fn copy_messages(&self, out: &mut Vec<Message>) {
+    fn message_raw(&mut self, message: impl Into<String>) {
+        self.message_raw(message)
+    }
+
+    fn copy_messages(&self, out: &mut Vec<Envelope>) {
         self.copy_messages(out)
     }
 
-    fn copy_new_messages(&self, out: &mut Vec<Message>, prev: Option<MessageCopyState>) -> MessageCopyState {
+    fn copy_new_messages(&self, out: &mut Vec<Envelope>, prev: Option<MessageCopyState>) -> MessageCopyState {
         self.copy_new_messages(out, prev)
     }
 }