git.iko.soy/bat
on v0.15.0 help sign in
bat/src/printer.rs
597 lines 21 kB history raw
1use std::io::Write;
2use std::vec::Vec;
4use ansi_term::Colour::{Fixed, Green, Red, Yellow};
5use ansi_term::Style;
7use console::AnsiCodeIterator;
9use syntect::easy::HighlightLines;
10use syntect::highlighting::Color;
11use syntect::highlighting::Theme;
12use syntect::parsing::SyntaxSet;
14use content_inspector::ContentType;
16use encoding::all::{UTF_16BE, UTF_16LE};
17use encoding::{DecoderTrap, Encoding};
19use unicode_width::UnicodeWidthChar;
21use crate::assets::HighlightingAssets;
22use crate::config::Config;
23#[cfg(feature = "git")]
24use crate::decorations::LineChangesDecoration;
25use crate::decorations::{Decoration, GridBorderDecoration, LineNumberDecoration};
26#[cfg(feature = "git")]
27use crate::diff::LineChanges;
28use crate::error::*;
29use crate::input::OpenedInput;
30use crate::line_range::RangeCheckResult;
31use crate::preprocessor::{expand_tabs, replace_nonprintable};
32use crate::terminal::{as_terminal_escaped, to_ansi_color};
33use crate::wrapping::WrappingMode;
35pub(crate) trait Printer {
36 fn print_header(&mut self, handle: &mut dyn Write, input: &OpenedInput) -> Result<()>;
37 fn print_footer(&mut self, handle: &mut dyn Write, input: &OpenedInput) -> Result<()>;
39 fn print_snip(&mut self, handle: &mut dyn Write) -> Result<()>;
41 fn print_line(
42 &mut self,
43 out_of_range: bool,
44 handle: &mut dyn Write,
45 line_number: usize,
46 line_buffer: &[u8],
47 ) -> Result<()>;
50pub struct SimplePrinter;
52impl SimplePrinter {
53 pub fn new() -> Self {
54 SimplePrinter {}
55 }
58impl Printer for SimplePrinter {
59 fn print_header(&mut self, _handle: &mut dyn Write, _input: &OpenedInput) -> Result<()> {
60 Ok(())
61 }
63 fn print_footer(&mut self, _handle: &mut dyn Write, _input: &OpenedInput) -> Result<()> {
64 Ok(())
65 }
67 fn print_snip(&mut self, _handle: &mut dyn Write) -> Result<()> {
68 Ok(())
69 }
71 fn print_line(
72 &mut self,
73 out_of_range: bool,
74 handle: &mut dyn Write,
75 _line_number: usize,
76 line_buffer: &[u8],
77 ) -> Result<()> {
78 if !out_of_range {
79 handle.write_all(line_buffer)?;
80 }
81 Ok(())
82 }
85pub(crate) struct InteractivePrinter<'a> {
86 colors: Colors,
87 config: &'a Config<'a>,
88 decorations: Vec<Box<dyn Decoration>>,
89 panel_width: usize,
90 ansi_prefix_sgr: String,
91 content_type: Option<ContentType>,
92 #[cfg(feature = "git")]
93 pub line_changes: &'a Option<LineChanges>,
94 highlighter: Option<HighlightLines<'a>>,
95 syntax_set: &'a SyntaxSet,
96 background_color_highlight: Option<Color>,
99impl<'a> InteractivePrinter<'a> {
100 pub(crate) fn new(
101 config: &'a Config,
102 assets: &'a HighlightingAssets,
103 input: &mut OpenedInput,
104 #[cfg(feature = "git")]
105 line_changes: &'a Option<LineChanges>,
106 ) -> Self {
107 let theme = assets.get_theme(&config.theme);
109 let background_color_highlight = theme.settings.line_highlight;
111 let colors = if config.colored_output {
112 Colors::colored(theme, config.true_color)
113 } else {
114 Colors::plain()
115 };
117 // Create decorations.
118 let mut decorations: Vec<Box<dyn Decoration>> = Vec::new();
120 if config.style_components.numbers() {
121 decorations.push(Box::new(LineNumberDecoration::new(&colors)));
122 }
124 #[cfg(feature = "git")]
125 {
126 if config.style_components.changes() {
127 decorations.push(Box::new(LineChangesDecoration::new(&colors)));
128 }
129 }
131 let mut panel_width: usize =
132 decorations.len() + decorations.iter().fold(0, |a, x| a + x.width());
134 // The grid border decoration isn't added until after the panel_width calculation, since the
135 // print_horizontal_line, print_header, and print_footer functions all assume the panel
136 // width is without the grid border.
137 if config.style_components.grid() && !decorations.is_empty() {
138 decorations.push(Box::new(GridBorderDecoration::new(&colors)));
139 }
141 // Disable the panel if the terminal is too small (i.e. can't fit 5 characters with the
142 // panel showing).
143 if config.term_width
144 < (decorations.len() + decorations.iter().fold(0, |a, x| a + x.width())) + 5
145 {
146 decorations.clear();
147 panel_width = 0;
148 }
150 let highlighter = if input
151 .reader
152 .content_type
153 .map_or(false, |c| c.is_binary() && !config.show_nonprintable)
154 {
155 None
156 } else {
157 // Determine the type of syntax for highlighting
158 let syntax = assets.get_syntax(config.language, input, &config.syntax_mapping);
159 Some(HighlightLines::new(syntax, theme))
160 };
162 InteractivePrinter {
163 panel_width,
164 colors,
165 config,
166 decorations,
167 content_type: input.reader.content_type,
168 ansi_prefix_sgr: String::new(),
169 #[cfg(feature = "git")]
170 line_changes,
171 highlighter,
172 syntax_set: &assets.syntax_set,
173 background_color_highlight,
174 }
175 }
177 fn print_horizontal_line(&mut self, handle: &mut dyn Write, grid_char: char) -> Result<()> {
178 if self.panel_width == 0 {
179 writeln!(
180 handle,
181 "{}",
182 self.colors.grid.paint("─".repeat(self.config.term_width))
183 )?;
184 } else {
185 let hline = "─".repeat(self.config.term_width - (self.panel_width + 1));
186 let hline = format!("{}{}{}", "─".repeat(self.panel_width), grid_char, hline);
187 writeln!(handle, "{}", self.colors.grid.paint(hline))?;
188 }
190 Ok(())
191 }
193 fn create_fake_panel(&self, text: &str) -> String {
194 if self.panel_width == 0 {
195 "".to_string()
196 } else {
197 let text_truncated: String = text.chars().take(self.panel_width - 1).collect();
198 let text_filled: String = format!(
199 "{}{}",
200 text_truncated,
201 " ".repeat(self.panel_width - 1 - text_truncated.len())
202 );
203 if self.config.style_components.grid() {
204 format!("{} │ ", text_filled)
205 } else {
206 text_filled
207 }
208 }
209 }
211 fn preprocess(&self, text: &str, cursor: &mut usize) -> String {
212 if self.config.tab_width > 0 {
213 expand_tabs(text, self.config.tab_width, cursor)
214 } else {
215 *cursor += text.len();
216 text.to_string()
217 }
218 }
221impl<'a> Printer for InteractivePrinter<'a> {
222 fn print_header(&mut self, handle: &mut dyn Write, input: &OpenedInput) -> Result<()> {
223 if !self.config.style_components.header() {
224 if Some(ContentType::BINARY) == self.content_type && !self.config.show_nonprintable {
225 writeln!(
226 handle,
227 "{}: Binary content from {} will not be printed to the terminal \
228 (but will be present if the output of 'bat' is piped). You can use 'bat -A' \
229 to show the binary file contents.",
230 Yellow.paint("[bat warning]"),
231 input.description().full,
232 )?;
233 } else if self.config.style_components.grid() {
234 self.print_horizontal_line(handle, '┬')?;
235 }
236 return Ok(());
237 }
239 if self.config.style_components.grid() {
240 self.print_horizontal_line(handle, '┬')?;
242 write!(
243 handle,
244 "{}{}",
245 " ".repeat(self.panel_width),
246 self.colors
247 .grid
248 .paint(if self.panel_width > 0 { "│ " } else { "" }),
249 )?;
250 } else {
251 write!(handle, "{}", " ".repeat(self.panel_width))?;
252 }
254 let mode = match self.content_type {
255 Some(ContentType::BINARY) => " <BINARY>",
256 Some(ContentType::UTF_16LE) => " <UTF-16LE>",
257 Some(ContentType::UTF_16BE) => " <UTF-16BE>",
258 None => " <EMPTY>",
259 _ => "",
260 };
262 let description = input.description();
264 writeln!(
265 handle,
266 "{}{}{}",
267 description.prefix,
268 self.colors.filename.paint(&description.name),
269 mode
270 )?;
272 if self.config.style_components.grid() {
273 if self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable {
274 self.print_horizontal_line(handle, '┼')?;
275 } else {
276 self.print_horizontal_line(handle, '┴')?;
277 }
278 }
280 Ok(())
281 }
283 fn print_footer(&mut self, handle: &mut dyn Write, _input: &OpenedInput) -> Result<()> {
284 if self.config.style_components.grid()
285 && (self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable)
286 {
287 self.print_horizontal_line(handle, '┴')
288 } else {
289 Ok(())
290 }
291 }
293 fn print_snip(&mut self, handle: &mut dyn Write) -> Result<()> {
294 let panel = self.create_fake_panel(" ...");
295 let panel_count = panel.chars().count();
297 let title = "8<";
298 let title_count = title.chars().count();
300 let snip_left = "─ ".repeat((self.config.term_width - panel_count - (title_count / 2)) / 4);
301 let snip_left_count = snip_left.chars().count(); // Can't use .len() with Unicode.
303 let snip_right =
304 " ─".repeat((self.config.term_width - panel_count - snip_left_count - title_count) / 2);
306 writeln!(
307 handle,
308 "{}",
309 self.colors
310 .grid
311 .paint(format!("{}{}{}{}", panel, snip_left, title, snip_right))
312 )?;
314 Ok(())
315 }
317 fn print_line(
318 &mut self,
319 out_of_range: bool,
320 handle: &mut dyn Write,
321 line_number: usize,
322 line_buffer: &[u8],
323 ) -> Result<()> {
324 let line = if self.config.show_nonprintable {
325 replace_nonprintable(&line_buffer, self.config.tab_width)
326 } else {
327 match self.content_type {
328 Some(ContentType::BINARY) | None => {
329 return Ok(());
330 }
331 Some(ContentType::UTF_16LE) => UTF_16LE
332 .decode(&line_buffer, DecoderTrap::Replace)
333 .map_err(|_| "Invalid UTF-16LE")?,
334 Some(ContentType::UTF_16BE) => UTF_16BE
335 .decode(&line_buffer, DecoderTrap::Replace)
336 .map_err(|_| "Invalid UTF-16BE")?,
337 _ => String::from_utf8_lossy(&line_buffer).to_string(),
338 }
339 };
341 let regions = {
342 let highlighter = match self.highlighter {
343 Some(ref mut highlighter) => highlighter,
344 _ => {
345 return Ok(());
346 }
347 };
348 highlighter.highlight(line.as_ref(), self.syntax_set)
349 };
351 if out_of_range {
352 return Ok(());
353 }
355 let mut cursor: usize = 0;
356 let mut cursor_max: usize = self.config.term_width;
357 let mut cursor_total: usize = 0;
358 let mut panel_wrap: Option<String> = None;
360 // Line highlighting
361 let highlight_this_line =
362 self.config.highlighted_lines.0.check(line_number) == RangeCheckResult::InRange;
364 let background_color = self
365 .background_color_highlight
366 .filter(|_| highlight_this_line);
368 // Line decorations.
369 if self.panel_width > 0 {
370 let decorations = self
371 .decorations
372 .iter()
373 .map(|ref d| d.generate(line_number, false, self))
374 .collect::<Vec<_>>();
376 for deco in decorations {
377 write!(handle, "{} ", deco.text)?;
378 cursor_max -= deco.width + 1;
379 }
380 }
382 // Line contents.
383 if self.config.wrapping_mode == WrappingMode::NoWrapping {
384 let true_color = self.config.true_color;
385 let colored_output = self.config.colored_output;
386 let italics = self.config.use_italic_text;
388 for &(style, region) in regions.iter() {
389 let text = &*self.preprocess(region, &mut cursor_total);
390 let text_trimmed = text.trim_end_matches(|c| c == '\r' || c == '\n');
391 write!(
392 handle,
393 "{}",
394 as_terminal_escaped(
395 style,
396 text_trimmed,
397 true_color,
398 colored_output,
399 italics,
400 background_color
401 )
402 )?;
404 if text.len() != text_trimmed.len() {
405 if let Some(background_color) = background_color {
406 let mut ansi_style = Style::default();
407 ansi_style.background = Some(to_ansi_color(background_color, true_color));
408 let width = if cursor_total <= cursor_max {
409 cursor_max - cursor_total + 1
410 } else {
411 0
412 };
413 write!(handle, "{}", ansi_style.paint(" ".repeat(width)))?;
414 }
415 write!(handle, "{}", &text[text_trimmed.len()..])?;
416 }
417 }
419 if line.bytes().next_back() != Some(b'\n') {
420 writeln!(handle)?;
421 }
422 } else {
423 for &(style, region) in regions.iter() {
424 let ansi_iterator = AnsiCodeIterator::new(region);
425 let mut ansi_prefix: String = String::new();
426 for chunk in ansi_iterator {
427 match chunk {
428 // ANSI escape passthrough.
429 (text, true) => {
430 let is_ansi_csi = text.starts_with("\x1B[");
432 if is_ansi_csi && text.ends_with('m') {
433 // It's an ANSI SGR sequence.
434 // We should be mostly safe to just append these together.
435 ansi_prefix.push_str(text);
436 if text == "\x1B[0m" {
437 self.ansi_prefix_sgr = "\x1B[0m".to_owned();
438 } else {
439 self.ansi_prefix_sgr.push_str(text);
440 }
441 } else if is_ansi_csi {
442 // It's a regular CSI sequence.
443 // We should be mostly safe to just append these together.
444 ansi_prefix.push_str(text);
445 } else {
446 // It's probably a VT100 code.
447 // Passing it through is the safest bet.
448 write!(handle, "{}", text)?;
449 }
450 }
452 // Regular text.
453 (text, false) => {
454 let text = self.preprocess(
455 text.trim_end_matches(|c| c == '\r' || c == '\n'),
456 &mut cursor_total,
457 );
459 let mut max_width = cursor_max - cursor;
461 // line buffer (avoid calling write! for every character)
462 let mut line_buf = String::with_capacity(max_width * 4);
464 // Displayed width of line_buf
465 let mut current_width = 0;
467 for c in text.chars() {
468 // calculate the displayed width for next character
469 let cw = c.width().unwrap_or(0);
470 current_width += cw;
472 // if next character cannot be printed on this line,
473 // flush the buffer.
474 if current_width > max_width {
475 // Generate wrap padding if not already generated.
476 if panel_wrap.is_none() {
477 panel_wrap = if self.panel_width > 0 {
478 Some(format!(
479 "{} ",
480 self.decorations
481 .iter()
482 .map(|ref d| d
483 .generate(line_number, true, self)
484 .text)
485 .collect::<Vec<String>>()
486 .join(" ")
487 ))
488 } else {
489 Some("".to_string())
490 }
491 }
493 // It wraps.
494 write!(
495 handle,
496 "{}\n{}",
497 as_terminal_escaped(
498 style,
499 &*format!(
500 "{}{}{}",
501 self.ansi_prefix_sgr, ansi_prefix, line_buf
502 ),
503 self.config.true_color,
504 self.config.colored_output,
505 self.config.use_italic_text,
506 background_color
507 ),
508 panel_wrap.clone().unwrap()
509 )?;
511 cursor = 0;
512 max_width = cursor_max;
514 line_buf.clear();
515 current_width = cw;
516 }
518 line_buf.push(c);
519 }
521 // flush the buffer
522 cursor += current_width;
523 write!(
524 handle,
525 "{}",
526 as_terminal_escaped(
527 style,
528 &*format!(
529 "{}{}{}",
530 self.ansi_prefix_sgr, ansi_prefix, line_buf
531 ),
532 self.config.true_color,
533 self.config.colored_output,
534 self.config.use_italic_text,
535 background_color
536 )
537 )?;
539 // Clear the ANSI prefix buffer.
540 ansi_prefix.clear();
541 }
542 }
543 }
544 }
546 if let Some(background_color) = background_color {
547 let mut ansi_style = Style::default();
548 ansi_style.background =
549 Some(to_ansi_color(background_color, self.config.true_color));
551 write!(
552 handle,
553 "{}",
554 ansi_style.paint(" ".repeat(cursor_max - cursor))
555 )?;
556 }
557 writeln!(handle)?;
558 }
560 Ok(())
561 }
564const DEFAULT_GUTTER_COLOR: u8 = 238;
566#[derive(Debug, Default)]
567pub struct Colors {
568 pub grid: Style,
569 pub filename: Style,
570 pub git_added: Style,
571 pub git_removed: Style,
572 pub git_modified: Style,
573 pub line_number: Style,
576impl Colors {
577 fn plain() -> Self {
578 Colors::default()
579 }
581 fn colored(theme: &Theme, true_color: bool) -> Self {
582 let gutter_color = theme
583 .settings
584 .gutter_foreground
585 .map(|c| to_ansi_color(c, true_color))
586 .unwrap_or(Fixed(DEFAULT_GUTTER_COLOR));
588 Colors {
589 grid: gutter_color.normal(),
590 filename: Style::new().bold(),
591 git_added: Green.normal(),
592 git_removed: Red.normal(),
593 git_modified: Yellow.normal(),
594 line_number: gutter_color.normal(),
595 }
596 }