bat/src/printer.rs

867 lines
30 KiB
Rust
Raw Normal View History

use std::fmt;
use std::io;
2018-08-22 22:29:12 +02:00
use std::vec::Vec;
use nu_ansi_term::Color::{Fixed, Green, Red, Yellow};
use nu_ansi_term::Style;
2018-08-22 22:29:12 +02:00
use bytesize::ByteSize;
2018-08-23 22:37:27 +02:00
use syntect::easy::HighlightLines;
2018-10-10 06:25:33 +02:00
use syntect::highlighting::Color;
use syntect::highlighting::FontStyle;
2018-08-23 22:37:27 +02:00
use syntect::highlighting::Theme;
2018-10-09 21:18:40 +02:00
use syntect::parsing::SyntaxSet;
2018-08-22 22:29:12 +02:00
2018-10-07 16:44:59 +02:00
use content_inspector::ContentType;
use encoding_rs::{UTF_16BE, UTF_16LE};
use unicode_width::UnicodeWidthChar;
use crate::assets::{HighlightingAssets, SyntaxReferenceInSet};
2020-03-21 19:40:43 +01:00
use crate::config::Config;
#[cfg(feature = "git")]
use crate::decorations::LineChangesDecoration;
2020-04-11 19:40:04 +02:00
use crate::decorations::{Decoration, GridBorderDecoration, LineNumberDecoration};
#[cfg(feature = "git")]
use crate::diff::LineChanges;
2020-04-22 21:45:47 +02:00
use crate::error::*;
use crate::input::OpenedInput;
2020-01-23 04:26:21 +01:00
use crate::line_range::RangeCheckResult;
use crate::preprocessor::{expand_tabs, replace_nonprintable};
use crate::style::StyleComponent;
use crate::terminal::{as_terminal_escaped, to_ansi_color};
use crate::vscreen::{AnsiStyle, EscapeSequence, EscapeSequenceIterator};
2020-04-22 20:34:40 +02:00
use crate::wrapping::WrappingMode;
const ANSI_UNDERLINE_ENABLE: EscapeSequence = EscapeSequence::CSI {
raw_sequence: "\x1B[4m",
parameters: "4",
intermediates: "",
final_byte: "m",
};
const ANSI_UNDERLINE_DISABLE: EscapeSequence = EscapeSequence::CSI {
raw_sequence: "\x1B[24m",
parameters: "24",
intermediates: "",
final_byte: "m",
};
const EMPTY_SYNTECT_STYLE: syntect::highlighting::Style = syntect::highlighting::Style {
foreground: Color {
r: 127,
g: 127,
b: 127,
a: 255,
},
background: Color {
r: 127,
g: 127,
b: 127,
a: 255,
},
font_style: FontStyle::empty(),
};
pub enum OutputHandle<'a> {
IoWrite(&'a mut dyn io::Write),
FmtWrite(&'a mut dyn fmt::Write),
}
impl<'a> OutputHandle<'a> {
fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> Result<()> {
match self {
Self::IoWrite(handle) => handle.write_fmt(args).map_err(Into::into),
Self::FmtWrite(handle) => handle.write_fmt(args).map_err(Into::into),
}
}
}
2020-04-22 18:30:06 +02:00
pub(crate) trait Printer {
2020-05-12 02:57:51 +02:00
fn print_header(
&mut self,
2023-07-09 02:20:58 +02:00
handle: &mut OutputHandle,
2020-05-12 02:57:51 +02:00
input: &OpenedInput,
add_header_padding: bool,
) -> Result<()>;
2023-07-09 02:20:58 +02:00
fn print_footer(&mut self, handle: &mut OutputHandle, input: &OpenedInput) -> Result<()>;
2023-07-09 02:20:58 +02:00
fn print_snip(&mut self, handle: &mut OutputHandle) -> Result<()>;
fn print_line(
&mut self,
2018-08-23 23:35:57 +02:00
out_of_range: bool,
2023-07-09 02:20:58 +02:00
handle: &mut OutputHandle,
line_number: usize,
line_buffer: &[u8],
) -> Result<()>;
}
pub struct SimplePrinter<'a> {
2020-09-20 20:47:21 +02:00
config: &'a Config<'a>,
consecutive_empty_lines: usize,
}
impl<'a> SimplePrinter<'a> {
pub fn new(config: &'a Config) -> Self {
SimplePrinter {
config,
consecutive_empty_lines: 0,
}
}
}
impl<'a> Printer for SimplePrinter<'a> {
2020-05-12 02:57:51 +02:00
fn print_header(
&mut self,
2023-07-09 02:20:58 +02:00
_handle: &mut OutputHandle,
2020-05-12 02:57:51 +02:00
_input: &OpenedInput,
_add_header_padding: bool,
) -> Result<()> {
Ok(())
}
2023-07-09 02:20:58 +02:00
fn print_footer(&mut self, _handle: &mut OutputHandle, _input: &OpenedInput) -> Result<()> {
Ok(())
}
2023-07-09 02:20:58 +02:00
fn print_snip(&mut self, _handle: &mut OutputHandle) -> Result<()> {
Ok(())
}
fn print_line(
&mut self,
2018-08-23 23:35:57 +02:00
out_of_range: bool,
2023-07-09 02:20:58 +02:00
handle: &mut OutputHandle,
_line_number: usize,
line_buffer: &[u8],
) -> Result<()> {
// Skip squeezed lines.
if let Some(squeeze_limit) = self.config.squeeze_lines {
if String::from_utf8_lossy(line_buffer)
.trim_end_matches(|c| c == '\r' || c == '\n')
.is_empty()
{
self.consecutive_empty_lines += 1;
if self.consecutive_empty_lines > squeeze_limit {
return Ok(());
}
} else {
self.consecutive_empty_lines = 0;
}
}
2018-08-23 23:35:57 +02:00
if !out_of_range {
if self.config.show_nonprintable {
let line = replace_nonprintable(
line_buffer,
self.config.tab_width,
self.config.nonprintable_notation,
);
write!(handle, "{line}")?;
} else {
match handle {
OutputHandle::IoWrite(handle) => handle.write_all(line_buffer)?,
2023-07-09 02:33:48 +02:00
OutputHandle::FmtWrite(handle) => {
write!(
handle,
"{}",
std::str::from_utf8(line_buffer).map_err(|_| Error::Msg(
"encountered invalid utf8 while printing to non-io buffer"
.to_string()
))?
)?;
}
}
};
2018-08-23 23:35:57 +02:00
}
Ok(())
}
2018-08-23 19:43:10 +02:00
}
struct HighlighterFromSet<'a> {
highlighter: HighlightLines<'a>,
syntax_set: &'a SyntaxSet,
}
impl<'a> HighlighterFromSet<'a> {
fn new(syntax_in_set: SyntaxReferenceInSet<'a>, theme: &'a Theme) -> Self {
Self {
highlighter: HighlightLines::new(syntax_in_set.syntax, theme),
syntax_set: syntax_in_set.syntax_set,
}
}
}
2020-04-22 18:30:06 +02:00
pub(crate) struct InteractivePrinter<'a> {
colors: Colors,
2018-08-23 22:37:27 +02:00
config: &'a Config<'a>,
2018-10-07 11:55:39 +02:00
decorations: Vec<Box<dyn Decoration>>,
2018-05-12 06:59:26 +02:00
panel_width: usize,
ansi_style: AnsiStyle,
content_type: Option<ContentType>,
#[cfg(feature = "git")]
pub line_changes: &'a Option<LineChanges>,
highlighter_from_set: Option<HighlighterFromSet<'a>>,
2018-12-16 21:00:18 +01:00
background_color_highlight: Option<Color>,
consecutive_empty_lines: usize,
}
2018-08-23 19:43:10 +02:00
impl<'a> InteractivePrinter<'a> {
2020-04-22 18:30:06 +02:00
pub(crate) fn new(
config: &'a Config,
assets: &'a HighlightingAssets,
2020-04-22 16:27:34 +02:00
input: &mut OpenedInput,
#[cfg(feature = "git")] line_changes: &'a Option<LineChanges>,
) -> Result<Self> {
2018-08-23 22:37:27 +02:00
let theme = assets.get_theme(&config.theme);
2018-12-16 21:00:18 +01:00
let background_color_highlight = theme.settings.line_highlight;
2018-10-10 06:25:33 +02:00
2018-05-10 23:39:13 +02:00
let colors = if config.colored_output {
Colors::colored(theme, config.true_color)
} else {
Colors::plain()
};
// Create decorations.
2018-10-07 11:55:39 +02:00
let mut decorations: Vec<Box<dyn Decoration>> = Vec::new();
if config.style_components.numbers() {
decorations.push(Box::new(LineNumberDecoration::new(&colors)));
}
#[cfg(feature = "git")]
{
if config.style_components.changes() {
decorations.push(Box::new(LineChangesDecoration::new(&colors)));
}
}
2018-05-15 23:09:51 +02:00
let mut panel_width: usize =
decorations.len() + decorations.iter().fold(0, |a, x| a + x.width());
// The grid border decoration isn't added until after the panel_width calculation, since the
// print_horizontal_line, print_header, and print_footer functions all assume the panel
// width is without the grid border.
if config.style_components.grid() && !decorations.is_empty() {
decorations.push(Box::new(GridBorderDecoration::new(&colors)));
}
2018-05-15 23:09:51 +02:00
// Disable the panel if the terminal is too small (i.e. can't fit 5 characters with the
// panel showing).
if config.term_width
< (decorations.len() + decorations.iter().fold(0, |a, x| a + x.width())) + 5
{
2018-05-15 23:09:51 +02:00
decorations.clear();
panel_width = 0;
}
// Get the highlighter for the output.
let is_printing_binary = input
2020-04-22 16:27:34 +02:00
.reader
2019-08-27 05:05:47 +02:00
.content_type
.map_or(false, |c| c.is_binary() && !config.show_nonprintable);
2024-03-11 08:40:08 +01:00
let highlighter_from_set = if is_printing_binary || !config.colored_output {
None
} else {
// Determine the type of syntax for highlighting
let syntax_in_set =
match assets.get_syntax(config.language, input, &config.syntax_mapping) {
Ok(syntax_in_set) => syntax_in_set,
Err(Error::UndetectedSyntax(_)) => assets
.find_syntax_by_name("Plain Text")?
.expect("A plain text syntax is available"),
Err(e) => return Err(e),
};
Some(HighlighterFromSet::new(syntax_in_set, theme))
2018-08-28 20:12:45 +02:00
};
2018-08-23 22:37:27 +02:00
Ok(InteractivePrinter {
panel_width,
colors,
2018-05-10 23:39:13 +02:00
config,
decorations,
2020-04-22 16:27:34 +02:00
content_type: input.reader.content_type,
ansi_style: AnsiStyle::new(),
#[cfg(feature = "git")]
2018-08-23 22:37:27 +02:00
line_changes,
highlighter_from_set,
2018-12-16 21:00:18 +01:00
background_color_highlight,
consecutive_empty_lines: 0,
})
}
2023-07-09 02:20:58 +02:00
fn print_horizontal_line_term(
&mut self,
handle: &mut OutputHandle,
style: Style,
) -> Result<()> {
writeln!(
handle,
"{}",
style.paint("".repeat(self.config.term_width))
)?;
Ok(())
}
2023-07-09 02:20:58 +02:00
fn print_horizontal_line(&mut self, handle: &mut OutputHandle, grid_char: char) -> Result<()> {
2018-08-23 19:43:10 +02:00
if self.panel_width == 0 {
self.print_horizontal_line_term(handle, self.colors.grid)?;
2018-08-23 19:43:10 +02:00
} else {
let hline = "".repeat(self.config.term_width - (self.panel_width + 1));
let hline = format!("{}{}{}", "".repeat(self.panel_width), grid_char, hline);
writeln!(handle, "{}", self.colors.grid.paint(hline))?;
2018-08-23 19:43:10 +02:00
}
Ok(())
}
fn create_fake_panel(&self, text: &str) -> String {
if self.panel_width == 0 {
return "".to_string();
}
let text_truncated: String = text.chars().take(self.panel_width - 1).collect();
let text_filled: String = format!(
"{}{}",
text_truncated,
" ".repeat(self.panel_width - 1 - text_truncated.len())
);
if self.config.style_components.grid() {
format!("{text_filled}")
} else {
text_filled
}
}
2024-01-21 18:04:58 +01:00
fn get_header_component_indent_length(&self) -> usize {
if self.config.style_components.grid() && self.panel_width > 0 {
self.panel_width + 2
} else {
self.panel_width
}
}
2023-07-09 02:20:58 +02:00
fn print_header_component_indent(&mut self, handle: &mut OutputHandle) -> Result<()> {
if self.config.style_components.grid() {
write!(
handle,
"{}{}",
" ".repeat(self.panel_width),
self.colors
.grid
.paint(if self.panel_width > 0 { "" } else { "" }),
)
} else {
write!(handle, "{}", " ".repeat(self.panel_width))
}
}
2024-01-21 17:25:24 +01:00
fn print_header_component_with_indent(
&mut self,
handle: &mut OutputHandle,
content: &str,
) -> Result<()> {
2024-01-21 17:13:11 +01:00
self.print_header_component_indent(handle)?;
writeln!(handle, "{content}")
2024-01-21 17:13:11 +01:00
}
2024-01-21 17:25:24 +01:00
fn print_header_multiline_component(
&mut self,
handle: &mut OutputHandle,
content: &str,
) -> Result<()> {
2024-01-21 17:13:11 +01:00
let mut content = content;
2024-01-21 18:04:58 +01:00
let content_width = self.config.term_width - self.get_header_component_indent_length();
2024-01-21 17:13:11 +01:00
while content.len() > content_width {
let (content_line, remaining) = content.split_at(content_width);
self.print_header_component_with_indent(handle, content_line)?;
content = remaining;
}
self.print_header_component_with_indent(handle, content)
}
fn highlight_regions_for_line<'b>(
&mut self,
line: &'b str,
) -> Result<Vec<(syntect::highlighting::Style, &'b str)>> {
let highlighter_from_set = match self.highlighter_from_set {
Some(ref mut highlighter_from_set) => highlighter_from_set,
_ => return Ok(vec![(EMPTY_SYNTECT_STYLE, line)]),
};
// skip syntax highlighting on long lines
let too_long = line.len() > 1024 * 16;
let for_highlighting: &str = if too_long { "\n" } else { line };
let mut highlighted_line = highlighter_from_set
.highlighter
.highlight_line(for_highlighting, highlighter_from_set.syntax_set)?;
if too_long {
highlighted_line[0].1 = &line;
}
Ok(highlighted_line)
}
fn preprocess(&self, text: &str, cursor: &mut usize) -> String {
if self.config.tab_width > 0 {
return expand_tabs(text, self.config.tab_width, cursor);
}
*cursor += text.len();
text.to_string()
}
2018-08-23 19:43:10 +02:00
}
2018-05-19 12:25:07 +02:00
2018-08-23 19:43:10 +02:00
impl<'a> Printer for InteractivePrinter<'a> {
2020-05-12 02:57:51 +02:00
fn print_header(
&mut self,
2023-07-09 02:20:58 +02:00
handle: &mut OutputHandle,
2020-05-12 02:57:51 +02:00
input: &OpenedInput,
add_header_padding: bool,
) -> Result<()> {
if add_header_padding && self.config.style_components.rule() {
self.print_horizontal_line_term(handle, self.colors.rule)?;
}
if !self.config.style_components.header() {
2019-08-31 19:35:04 +02:00
if Some(ContentType::BINARY) == self.content_type && !self.config.show_nonprintable {
writeln!(
handle,
"{}: Binary content from {} will not be printed to the terminal \
(but will be present if the output of 'bat' is piped). You can use 'bat -A' \
to show the binary file contents.",
Yellow.paint("[bat warning]"),
2020-05-16 01:18:10 +02:00
input.description.summary(),
)?;
} else if self.config.style_components.grid() {
self.print_horizontal_line(handle, '┬')?;
}
return Ok(());
}
2018-10-07 16:44:59 +02:00
let mode = match self.content_type {
Some(ContentType::BINARY) => " <BINARY>",
Some(ContentType::UTF_16LE) => " <UTF-16LE>",
Some(ContentType::UTF_16BE) => " <UTF-16BE>",
None => " <EMPTY>",
2018-10-07 17:01:26 +02:00
_ => "",
};
2020-05-16 01:18:10 +02:00
let description = &input.description;
let metadata = &input.metadata;
// We use this iterator to have a deterministic order for
// header components. HashSet has arbitrary order, but Vec is ordered.
let header_components: Vec<StyleComponent> = [
(
StyleComponent::HeaderFilename,
self.config.style_components.header_filename(),
),
(
StyleComponent::HeaderFilesize,
self.config.style_components.header_filesize(),
),
]
.iter()
.filter(|(_, is_enabled)| *is_enabled)
.map(|(component, _)| *component)
.collect();
// Print the cornering grid before the first header component
if self.config.style_components.grid() {
self.print_horizontal_line(handle, '┬')?;
} else {
// Only pad space between files, if we haven't already drawn a horizontal rule
if add_header_padding && !self.config.style_components.rule() {
writeln!(handle)?;
}
}
2020-04-22 16:27:34 +02:00
2024-01-21 17:25:24 +01:00
header_components
.iter()
.try_for_each(|component| match component {
2024-01-21 17:13:11 +01:00
StyleComponent::HeaderFilename => {
let header_filename = format!(
"{}{}{}",
description
.kind()
.map(|kind| format!("{kind}: "))
2024-01-21 17:13:11 +01:00
.unwrap_or_else(|| "".into()),
self.colors.header_value.paint(description.title()),
mode
);
self.print_header_multiline_component(handle, &header_filename)
}
StyleComponent::HeaderFilesize => {
let bsize = metadata
.size
.map(|s| format!("{}", ByteSize(s)))
.unwrap_or_else(|| "-".into());
2024-01-21 17:25:24 +01:00
let header_filesize =
format!("Size: {}", self.colors.header_value.paint(bsize));
2024-01-21 17:13:11 +01:00
self.print_header_multiline_component(handle, &header_filesize)
}
_ => Ok(()),
2024-01-21 17:25:24 +01:00
})?;
if self.config.style_components.grid() {
if self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable {
self.print_horizontal_line(handle, '┼')?;
} else {
self.print_horizontal_line(handle, '┴')?;
}
}
Ok(())
}
2023-07-09 02:20:58 +02:00
fn print_footer(&mut self, handle: &mut OutputHandle, _input: &OpenedInput) -> Result<()> {
if self.config.style_components.grid()
&& (self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable)
{
2018-08-23 22:37:27 +02:00
self.print_horizontal_line(handle, '┴')
} else {
Ok(())
}
}
2023-07-09 02:20:58 +02:00
fn print_snip(&mut self, handle: &mut OutputHandle) -> Result<()> {
let panel = self.create_fake_panel(" ...");
let panel_count = panel.chars().count();
let title = "8<";
let title_count = title.chars().count();
2019-08-31 12:46:27 +02:00
let snip_left = "".repeat((self.config.term_width - panel_count - (title_count / 2)) / 4);
let snip_left_count = snip_left.chars().count(); // Can't use .len() with Unicode.
2019-08-31 12:46:27 +02:00
let snip_right =
"".repeat((self.config.term_width - panel_count - snip_left_count - title_count) / 2);
writeln!(
handle,
"{}",
self.colors
.grid
.paint(format!("{panel}{snip_left}{title}{snip_right}"))
)?;
Ok(())
}
fn print_line(
&mut self,
2018-08-23 23:35:57 +02:00
out_of_range: bool,
2023-07-09 02:20:58 +02:00
handle: &mut OutputHandle,
line_number: usize,
line_buffer: &[u8],
) -> Result<()> {
let line = if self.config.show_nonprintable {
replace_nonprintable(
line_buffer,
self.config.tab_width,
self.config.nonprintable_notation,
)
.into()
} else {
match self.content_type {
Some(ContentType::BINARY) | None => {
return Ok(());
}
Some(ContentType::UTF_16LE) => UTF_16LE.decode_with_bom_removal(line_buffer).0,
Some(ContentType::UTF_16BE) => UTF_16BE.decode_with_bom_removal(line_buffer).0,
_ => {
let line = String::from_utf8_lossy(line_buffer);
if line_number == 1 {
match line.strip_prefix('\u{feff}') {
Some(stripped) => stripped.to_string().into(),
None => line,
}
} else {
line
}
}
2018-10-07 16:44:59 +02:00
}
};
2018-11-01 20:29:48 +01:00
let regions = self.highlight_regions_for_line(&line)?;
2018-08-23 23:35:57 +02:00
if out_of_range {
return Ok(());
}
// Skip squeezed lines.
if let Some(squeeze_limit) = self.config.squeeze_lines {
if line.trim_end_matches(|c| c == '\r' || c == '\n').is_empty() {
self.consecutive_empty_lines += 1;
if self.consecutive_empty_lines > squeeze_limit {
return Ok(());
}
} else {
self.consecutive_empty_lines = 0;
}
}
let mut cursor: usize = 0;
let mut cursor_max: usize = self.config.term_width;
let mut cursor_total: usize = 0;
let mut panel_wrap: Option<String> = None;
2018-12-16 21:00:18 +01:00
// Line highlighting
2020-01-23 04:26:21 +01:00
let highlight_this_line =
self.config.highlighted_lines.0.check(line_number) == RangeCheckResult::InRange;
2018-12-16 21:53:15 +01:00
if highlight_this_line && self.config.theme == "ansi" {
self.ansi_style.update(ANSI_UNDERLINE_ENABLE);
}
2018-12-16 21:53:15 +01:00
let background_color = self
.background_color_highlight
.filter(|_| highlight_this_line);
2018-12-16 21:00:18 +01:00
// Line decorations.
if self.panel_width > 0 {
2018-07-17 23:38:45 +02:00
let decorations = self
.decorations
.iter()
2021-09-10 21:56:40 +02:00
.map(|d| d.generate(line_number, false, self));
for deco in decorations {
write!(handle, "{} ", deco.text)?;
cursor_max -= deco.width + 1;
}
}
// Line contents.
if matches!(self.config.wrapping_mode, WrappingMode::NoWrapping(_)) {
let true_color = self.config.true_color;
let colored_output = self.config.colored_output;
let italics = self.config.use_italic_text;
2018-11-02 12:41:56 +01:00
2021-09-10 21:56:40 +02:00
for &(style, region) in &regions {
let ansi_iterator = EscapeSequenceIterator::new(region);
for chunk in ansi_iterator {
match chunk {
// Regular text.
EscapeSequence::Text(text) => {
2023-04-18 04:19:49 +02:00
let text = self.preprocess(text, &mut cursor_total);
let text_trimmed = text.trim_end_matches(|c| c == '\r' || c == '\n');
write!(
handle,
2023-04-18 04:19:49 +02:00
"{}{}",
as_terminal_escaped(
style,
&format!("{}{}", self.ansi_style, text_trimmed),
true_color,
colored_output,
italics,
background_color
2023-04-18 04:19:49 +02:00
),
self.ansi_style.to_reset_sequence(),
)?;
2023-04-18 04:19:49 +02:00
// Pad the rest of the line.
if text.len() != text_trimmed.len() {
if let Some(background_color) = background_color {
let ansi_style = Style {
background: to_ansi_color(background_color, true_color),
..Default::default()
};
let width = if cursor_total <= cursor_max {
cursor_max - cursor_total + 1
} else {
0
};
write!(handle, "{}", ansi_style.paint(" ".repeat(width)))?;
}
write!(handle, "{}", &text[text_trimmed.len()..])?;
}
}
// ANSI escape passthrough.
_ => {
write!(handle, "{}", chunk.raw())?;
self.ansi_style.update(chunk);
}
2018-12-16 21:53:15 +01:00
}
}
}
if !self.config.style_components.plain() && line.bytes().next_back() != Some(b'\n') {
writeln!(handle)?;
}
} else {
2021-09-10 21:56:40 +02:00
for &(style, region) in &regions {
let ansi_iterator = EscapeSequenceIterator::new(region);
for chunk in ansi_iterator {
match chunk {
// Regular text.
EscapeSequence::Text(text) => {
let text = self.preprocess(
text.trim_end_matches(|c| c == '\r' || c == '\n'),
&mut cursor_total,
);
let mut max_width = cursor_max - cursor;
// line buffer (avoid calling write! for every character)
let mut line_buf = String::with_capacity(max_width * 4);
// Displayed width of line_buf
let mut current_width = 0;
for c in text.chars() {
// calculate the displayed width for next character
let cw = c.width().unwrap_or(0);
current_width += cw;
// if next character cannot be printed on this line,
// flush the buffer.
if current_width > max_width {
// Generate wrap padding if not already generated.
if panel_wrap.is_none() {
panel_wrap = if self.panel_width > 0 {
Some(format!(
"{} ",
self.decorations
.iter()
.map(|d| d
.generate(line_number, true, self)
.text)
.collect::<Vec<String>>()
.join(" ")
))
} else {
Some("".to_string())
}
}
// It wraps.
write!(
handle,
2023-04-18 04:19:49 +02:00
"{}{}\n{}",
as_terminal_escaped(
style,
2023-03-14 21:19:14 +01:00
&format!("{}{}", self.ansi_style, line_buf),
self.config.true_color,
self.config.colored_output,
self.config.use_italic_text,
background_color
),
2023-04-18 04:19:49 +02:00
self.ansi_style.to_reset_sequence(),
panel_wrap.clone().unwrap()
)?;
cursor = 0;
max_width = cursor_max;
line_buf.clear();
current_width = cw;
}
line_buf.push(c);
}
// flush the buffer
cursor += current_width;
write!(
handle,
"{}",
as_terminal_escaped(
style,
2023-03-14 21:19:14 +01:00
&format!("{}{}", self.ansi_style, line_buf),
self.config.true_color,
self.config.colored_output,
self.config.use_italic_text,
background_color
)
)?;
}
// ANSI escape passthrough.
_ => {
write!(handle, "{}", chunk.raw())?;
self.ansi_style.update(chunk);
}
}
2018-05-12 06:59:26 +02:00
}
}
2018-12-16 21:53:15 +01:00
if let Some(background_color) = background_color {
2021-05-21 15:47:27 +02:00
let ansi_style = Style {
background: to_ansi_color(background_color, self.config.true_color),
..Default::default()
};
2018-12-16 21:53:15 +01:00
write!(
2018-12-16 21:53:15 +01:00
handle,
"{}",
ansi_style.paint(" ".repeat(cursor_max - cursor))
)?;
}
writeln!(handle)?;
}
2018-05-12 06:59:26 +02:00
if highlight_this_line && self.config.theme == "ansi" {
write!(handle, "{}", ANSI_UNDERLINE_DISABLE.raw())?;
self.ansi_style.update(ANSI_UNDERLINE_DISABLE);
}
Ok(())
}
}
2018-05-21 15:00:00 +02:00
const DEFAULT_GUTTER_COLOR: u8 = 238;
2018-05-21 15:00:00 +02:00
2019-10-15 03:25:53 +02:00
#[derive(Debug, Default)]
2018-05-21 15:00:00 +02:00
pub struct Colors {
pub grid: Style,
pub rule: Style,
pub header_value: Style,
2018-05-21 15:00:00 +02:00
pub git_added: Style,
pub git_removed: Style,
pub git_modified: Style,
pub line_number: Style,
}
impl Colors {
fn plain() -> Self {
Colors::default()
}
fn colored(theme: &Theme, true_color: bool) -> Self {
let gutter_style = Style {
foreground: match theme.settings.gutter_foreground {
// If the theme provides a gutter foreground color, use it.
// Note: It might be the special value #00000001, in which case
// to_ansi_color returns None and we use an empty Style
// (resulting in the terminal's default foreground color).
Some(c) => to_ansi_color(c, true_color),
// Otherwise, use a specific fallback color.
None => Some(Fixed(DEFAULT_GUTTER_COLOR)),
},
..Style::default()
};
2018-05-21 15:00:00 +02:00
Colors {
grid: gutter_style,
rule: gutter_style,
header_value: Style::new().bold(),
2018-05-21 15:00:00 +02:00
git_added: Green.normal(),
git_removed: Red.normal(),
git_modified: Yellow.normal(),
line_number: gutter_style,
2018-05-21 15:00:00 +02:00
}
}
}