use std::io::{self, Write};
use crate::style::*;
pub struct Output {
writer: Box<dyn Write + Send>,
}
impl Output {
pub fn stdout() -> Self {
Self {
writer: Box::new(io::stdout()),
}
}
pub fn stderr() -> Self {
Self {
writer: Box::new(io::stderr()),
}
}
pub fn new(writer: Box<dyn Write + Send>) -> Self {
Self { writer }
}
pub fn line(&mut self, text: &str) -> io::Result<()> {
writeln!(self, "{text}")
}
pub fn blank(&mut self) -> io::Result<()> {
writeln!(self)
}
pub fn raw(&mut self, bytes: &[u8]) -> io::Result<()> {
self.writer.write_all(bytes)
}
pub fn success(&mut self, msg: &str) -> io::Result<()> {
writeln!(self, "{GREEN}{msg}{RESET}")
}
pub fn error(&mut self, msg: &str) -> io::Result<()> {
writeln!(self, "{RED}{msg}{RESET}")
}
pub fn warning(&mut self, msg: &str) -> io::Result<()> {
writeln!(self, "{ORANGE}{msg}{RESET}")
}
pub fn info(&mut self, msg: &str) -> io::Result<()> {
writeln!(self, "{BLUE}{msg}{RESET}")
}
pub fn dim(&mut self, msg: &str) -> io::Result<()> {
writeln!(self, "{GRAY}{msg}{RESET}")
}
pub fn bold(&mut self, msg: &str) -> io::Result<()> {
writeln!(self, "{BOLD}{msg}{RESET}")
}
pub fn styled_line(&mut self, prefix: &str, text: &str, suffix: &str) -> io::Result<()> {
writeln!(self, "{prefix}{text}{suffix}")
}
}
impl Write for Output {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.writer.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.writer.flush()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
use std::sync::{Arc, Mutex};
#[derive(Clone)]
struct TestWriter {
buf: Arc<Mutex<Vec<u8>>>,
}
impl TestWriter {
fn new() -> (Self, Arc<Mutex<Vec<u8>>>) {
let buf = Arc::new(Mutex::new(Vec::new()));
let writer = TestWriter { buf: buf.clone() };
(writer, buf)
}
}
impl Write for TestWriter {
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
self.buf.lock().unwrap().extend_from_slice(data);
Ok(data.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
fn captured_output() -> (Output, Arc<Mutex<Vec<u8>>>) {
let (writer, buf) = TestWriter::new();
let output = Output::new(Box::new(writer));
(output, buf)
}
fn captured_string(buf: &Arc<Mutex<Vec<u8>>>) -> String {
String::from_utf8(buf.lock().unwrap().clone()).unwrap()
}
fn strip_ansi(s: &str) -> String {
let re = regex::Regex::new(r"\x1b\[[0-9;]*m").unwrap();
re.replace_all(s, "").to_string()
}
#[test]
fn line_writes_text_with_newline() {
let (mut out, buf) = captured_output();
out.line("hello").unwrap();
let raw = captured_string(&buf);
assert_eq!(raw, "hello\n");
}
#[test]
fn line_empty_string() {
let (mut out, buf) = captured_output();
out.line("").unwrap();
assert_eq!(captured_string(&buf), "\n");
}
#[test]
fn blank_writes_newline() {
let (mut out, buf) = captured_output();
out.blank().unwrap();
assert_eq!(captured_string(&buf), "\n");
}
#[test]
fn raw_writes_bytes_exactly() {
let (mut out, buf) = captured_output();
out.raw(b"no newline").unwrap();
assert_eq!(captured_string(&buf), "no newline");
}
#[test]
fn raw_empty_bytes() {
let (mut out, buf) = captured_output();
out.raw(b"").unwrap();
assert!(captured_string(&buf).is_empty());
}
#[test]
fn raw_no_newline_appended() {
let (mut out, buf) = captured_output();
out.raw(b"abc").unwrap();
assert!(!captured_string(&buf).ends_with('\n'));
}
#[test]
fn success_wraps_in_green() {
let (mut out, buf) = captured_output();
out.success("OK").unwrap();
let raw = captured_string(&buf);
assert!(raw.contains(GREEN), "should contain GREEN ANSI code");
assert!(raw.contains(RESET), "should contain RESET");
assert_eq!(strip_ansi(&raw), "OK\n");
}
#[test]
fn error_wraps_in_red() {
let (mut out, buf) = captured_output();
out.error("FAIL").unwrap();
let raw = captured_string(&buf);
assert!(raw.contains(RED), "should contain RED ANSI code");
assert!(raw.contains(RESET), "should contain RESET");
assert_eq!(strip_ansi(&raw), "FAIL\n");
}
#[test]
fn warning_wraps_in_orange() {
let (mut out, buf) = captured_output();
out.warning("careful").unwrap();
let raw = captured_string(&buf);
assert!(raw.contains(ORANGE), "should contain ORANGE ANSI code");
assert!(raw.contains(RESET), "should contain RESET");
assert_eq!(strip_ansi(&raw), "careful\n");
}
#[test]
fn info_wraps_in_blue() {
let (mut out, buf) = captured_output();
out.info("note").unwrap();
let raw = captured_string(&buf);
assert!(raw.contains(BLUE), "should contain BLUE ANSI code");
assert!(raw.contains(RESET), "should contain RESET");
assert_eq!(strip_ansi(&raw), "note\n");
}
#[test]
fn dim_wraps_in_gray() {
let (mut out, buf) = captured_output();
out.dim("subtle").unwrap();
let raw = captured_string(&buf);
assert!(raw.contains(GRAY), "should contain GRAY ANSI code");
assert!(raw.contains(RESET), "should contain RESET");
assert_eq!(strip_ansi(&raw), "subtle\n");
}
#[test]
fn bold_wraps_in_bold() {
let (mut out, buf) = captured_output();
out.bold("loud").unwrap();
let raw = captured_string(&buf);
assert!(raw.contains(BOLD), "should contain BOLD ANSI code");
assert!(raw.contains(RESET), "should contain RESET");
assert_eq!(strip_ansi(&raw), "loud\n");
}
#[test]
fn styled_line_custom_prefix_and_suffix() {
let (mut out, buf) = captured_output();
out.styled_line("[", "body", "]").unwrap();
assert_eq!(captured_string(&buf), "[body]\n");
}
#[test]
fn styled_line_with_ansi_codes() {
let (mut out, buf) = captured_output();
out.styled_line(BOLD, "Header", RESET).unwrap();
let raw = captured_string(&buf);
assert!(raw.starts_with(BOLD));
assert!(raw.trim_end().ends_with(RESET));
assert_eq!(strip_ansi(&raw), "Header\n");
}
#[test]
fn writeln_macro_works() {
let (mut out, buf) = captured_output();
let _ = writeln!(out, "formatted {}", 42);
assert_eq!(captured_string(&buf), "formatted 42\n");
}
#[test]
fn write_macro_no_newline() {
let (mut out, buf) = captured_output();
let _ = write!(out, "no newline");
assert_eq!(captured_string(&buf), "no newline");
}
#[test]
fn writeln_with_ansi_constants() {
let (mut out, buf) = captured_output();
let _ = writeln!(out, "{GREEN}ok{RESET}");
let raw = captured_string(&buf);
assert!(raw.contains(GREEN));
assert!(raw.contains(RESET));
assert_eq!(strip_ansi(&raw), "ok\n");
}
#[test]
fn write_then_flush() {
let (mut out, buf) = captured_output();
let _ = write!(out, "partial");
assert!(out.flush().is_ok());
assert_eq!(captured_string(&buf), "partial");
}
#[test]
fn writeln_empty() {
let (mut out, buf) = captured_output();
let _ = writeln!(out);
assert_eq!(captured_string(&buf), "\n");
}
#[test]
fn multiple_operations_append() {
let (mut out, buf) = captured_output();
out.line("first").unwrap();
out.success("ok").unwrap();
let _ = writeln!(out, "{BOLD}bold{RESET}");
let raw = captured_string(&buf);
let plain = strip_ansi(&raw);
assert_eq!(plain, "first\nok\nbold\n");
}
#[test]
fn blank_between_lines() {
let (mut out, buf) = captured_output();
out.line("a").unwrap();
out.blank().unwrap();
out.line("b").unwrap();
assert_eq!(captured_string(&buf), "a\n\nb\n");
}
#[test]
fn success_empty_message() {
let (mut out, buf) = captured_output();
out.success("").unwrap();
let raw = captured_string(&buf);
assert!(raw.contains(GREEN));
assert!(raw.contains(RESET));
assert_eq!(strip_ansi(&raw), "\n");
}
#[test]
fn unicode_text() {
let (mut out, buf) = captured_output();
out.line("zażółć gęślą jaźń 🦀").unwrap();
let raw = captured_string(&buf);
assert_eq!(raw, "zażółć gęślą jaźń 🦀\n");
}
#[test]
fn long_text_no_panic() {
let (mut out, buf) = captured_output();
let long = "x".repeat(10_000);
out.line(&long).unwrap();
assert_eq!(captured_string(&buf).len(), 10_001); }
#[test]
fn stdout_constructs() {
let _out = Output::stdout();
}
#[test]
fn stderr_constructs() {
let _out = Output::stderr();
}
#[test]
fn new_with_boxed_writer() {
let buf = Box::new(Vec::new());
let mut out = Output::new(buf);
out.line("test").unwrap();
}
}