use std::fs;
use std::io::Write;
use std::process::Command;
use std::time::Duration;
use crate::terminal::attributed::attributed_screen_from_text;
use crate::terminal::attributed::screen_svg;
use crate::terminal::attributed::AttributedScreen;
use crate::terminal::attributed::SvgMetrics;
use crate::terminal::attributed::DEFAULT_CELL_H;
use crate::terminal::attributed::DEFAULT_CELL_W;
use crate::terminal::attributed::DEFAULT_COLUMNS;
use crate::terminal::attributed::DEFAULT_FONT_PX;
use crate::terminal::attributed::DEFAULT_PADDING;
use crate::terminal::attributed::DEFAULT_ROWS;
use crate::terminal::proc::combined_output;
use crate::terminal::proc::run_with_timeout;
const RSVG_CONVERT: &str = "/usr/bin/rsvg-convert";
const TOOL_TIMEOUT: Duration = Duration::from_secs(30);
pub type ToolRunner = Box<dyn Fn(&str, &[String], Duration) -> Result<(), String> + Send + Sync>;
pub fn default_runner() -> ToolRunner {
Box::new(|executable, args, timeout| {
let mut cmd = Command::new(executable);
cmd.args(args);
let output = run_with_timeout(cmd, timeout).map_err(|e| e.to_string())?;
if !output.status.success() {
return Err(format!(
"{} exited {}: {}",
executable,
output.status.code().unwrap_or(-1),
combined_output(&output),
));
}
Ok(())
})
}
pub struct ScreenshotRenderer {
pub columns: usize,
pub rows: usize,
pub cell_w: f64,
pub cell_h: f64,
pub font_px: u32,
pub padding: u32,
runner: ToolRunner,
}
impl Default for ScreenshotRenderer {
fn default() -> Self {
ScreenshotRenderer {
columns: DEFAULT_COLUMNS,
rows: DEFAULT_ROWS,
cell_w: DEFAULT_CELL_W,
cell_h: DEFAULT_CELL_H,
font_px: DEFAULT_FONT_PX,
padding: DEFAULT_PADDING,
runner: default_runner(),
}
}
}
impl ScreenshotRenderer {
pub fn new() -> Self {
Self::default()
}
pub fn with_runner(runner: ToolRunner) -> Self {
ScreenshotRenderer {
runner,
..Self::default()
}
}
pub fn metrics(&self) -> SvgMetrics {
let mut metrics = SvgMetrics {
columns: self.columns,
rows: self.rows,
cell_w: self.cell_w,
cell_h: self.cell_h,
font_px: self.font_px,
padding: self.padding,
width: 0,
height: 0,
};
metrics.recompute();
metrics
}
pub fn width(&self) -> usize {
self.metrics().width
}
pub fn height(&self) -> usize {
self.metrics().height
}
pub fn render(
&self,
screen_text: &str,
png_path: &str,
attributed_screen: Option<&AttributedScreen>,
) -> Result<String, String> {
if let Some(parent) = std::path::Path::new(png_path).parent() {
if !parent.as_os_str().is_empty() {
fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
}
let fallback;
let screen = match attributed_screen {
Some(screen) => screen,
None => {
fallback = attributed_screen_from_text(screen_text, self.columns, self.rows);
&fallback
}
};
let svg = screen_svg(screen, &self.metrics());
let mut tmp = tempfile::Builder::new()
.prefix("termproof_shot_")
.suffix(".svg")
.tempfile()
.map_err(|e| e.to_string())?;
tmp.write_all(svg.as_bytes()).map_err(|e| e.to_string())?;
let svg_path = tmp.path().to_string_lossy().to_string();
let result = (self.runner)(
RSVG_CONVERT,
&["--output".to_string(), png_path.to_string(), svg_path],
TOOL_TIMEOUT,
);
result?;
Ok(png_path.to_string())
}
}
#[cfg(test)]
mod tests {
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::sync::Mutex;
use super::*;
use crate::terminal::attributed::attributed_screen_from_ansi_text;
use crate::terminal::attributed::DEFAULT_BG;
use crate::terminal::attributed::DEFAULT_FG;
fn capturing_renderer() -> (ScreenshotRenderer, Arc<Mutex<String>>) {
let svg = Arc::new(Mutex::new(String::new()));
let sink = svg.clone();
let renderer = ScreenshotRenderer::with_runner(Box::new(move |_, args, _| {
*sink.lock().expect("poisoned") = fs::read_to_string(&args[2]).expect("svg written");
Ok(())
}));
(renderer, svg)
}
fn render_to_svg(renderer: &ScreenshotRenderer, text: &str, screen: Option<&AttributedScreen>) {
let dir = tempfile::tempdir().unwrap();
let png = dir.path().join("out.png").to_string_lossy().to_string();
renderer.render(text, &png, screen).unwrap();
}
#[test]
fn render_invokes_runner_and_writes_svg() {
let called = Arc::new(AtomicBool::new(false));
let called2 = called.clone();
let renderer = ScreenshotRenderer::with_runner(Box::new(move |exe, args, _| {
called2.store(true, Ordering::SeqCst);
assert_eq!(exe, RSVG_CONVERT);
assert_eq!(args[0], "--output");
assert!(args[2].ends_with(".svg"));
Ok(())
}));
let dir = tempfile::tempdir().unwrap();
let png = dir.path().join("out.png").to_string_lossy().to_string();
let path = renderer.render("hello\nworld", &png, None).unwrap();
assert_eq!(path, png);
assert!(called.load(Ordering::SeqCst));
}
#[test]
fn render_propagates_runner_error() {
let renderer = ScreenshotRenderer::with_runner(Box::new(|_, _, _| Err("boom".to_string())));
let dir = tempfile::tempdir().unwrap();
let png = dir.path().join("out.png").to_string_lossy().to_string();
assert!(renderer.render("x", &png, None).is_err());
}
#[test]
fn plain_text_renders_in_default_colors() {
let (renderer, svg) = capturing_renderer();
render_to_svg(&renderer, "hi", None);
let svg = svg.lock().unwrap().clone();
assert!(svg.contains(&format!("fill=\"{}\">h</text>", DEFAULT_FG)));
assert_eq!(svg.matches("<rect").count(), 1);
}
#[test]
fn attributed_screen_wins_over_the_text() {
let (renderer, svg) = capturing_renderer();
let screen = attributed_screen_from_ansi_text("\x1b[31mZ", DEFAULT_COLUMNS, DEFAULT_ROWS);
render_to_svg(&renderer, "hi", Some(&screen));
let svg = svg.lock().unwrap().clone();
assert!(svg.contains("fill=\"#ff7b72\">Z</text>"));
assert!(!svg.contains(">h</text>"));
}
#[test]
fn no_control_characters_reach_the_svg() {
let (renderer, svg) = capturing_renderer();
render_to_svg(&renderer, "ok \x1b[31mred\x1b[0m\x07 done", None);
let svg = svg.lock().unwrap().clone();
assert!(
!svg.chars().any(char::is_control),
"control character reached the SVG"
);
}
#[test]
fn canvas_is_derived_from_the_grid() {
let renderer = ScreenshotRenderer::new();
assert_eq!(renderer.width(), 120 * 10 + 20);
assert_eq!(renderer.height(), (40.0 * 22.0) as usize + 20);
let (renderer, svg) = capturing_renderer();
render_to_svg(&renderer, "hi", None);
let svg = svg.lock().unwrap().clone();
assert!(svg.contains("width=\"1220\" height=\"900\""));
assert!(svg.contains(&format!("fill=\"{}\"", DEFAULT_BG)));
}
}