24024608060

Committed 06 Apr 2026 08:20AM UTC coverage: 62.628% (+0.5%) from 62.154%

Build # 24024608060

Build Type

push

github

Committed by

deepu105

Commit Message

feat: Add inline filter to Context page

Coverage Stats

54 of 95 new or added lines in 3 files covered. (56.84%)

651 existing lines in 31 files now uncovered.

6363 of 10160 relevant lines covered (62.63%)

212.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.93

/src/ui/utils.rs

use std::{collections::BTreeMap, rc::Rc, sync::OnceLock};

use glob_match::glob_match;
use ratatui::{
  layout::{Constraint, Direction, Layout, Rect},
  style::{Color, Modifier, Style},
  symbols,
  text::{Line, Span, Text},
  widgets::{Block, Borders, Paragraph, Row, Table, Wrap},
  Frame,
};
use serde::Serialize;

use super::HIGHLIGHT;
use crate::app::{
  models::{KubeResource, StatefulTable},
  ActiveBlock, App,
};
// Utils

pub static COPY_HINT: &str = "| copy <c>";
pub static DESCRIBE_AND_YAML_HINT: &str = "| describe <d> | yaml <y> ";
pub static DESCRIBE_YAML_AND_LOGS_HINT: &str = "| describe <d> | yaml <y> | logs <o> ";
pub static DESCRIBE_YAML_LOGS_AND_ESC_HINT: &str =
  "| describe <d> | yaml <y> | logs <o> | back to menu <esc> ";
pub static DESCRIBE_YAML_AND_ESC_HINT: &str = "| describe <d> | yaml <y> | back to menu <esc> ";
pub static DESCRIBE_YAML_DECODE_AND_ESC_HINT: &str =
  "| describe <d> | yaml <y> | decode <x> | back to menu <esc> ";

// default colors
pub const COLOR_TEAL: Color = Color::Rgb(35, 50, 55);
pub const COLOR_CYAN: Color = Color::Rgb(0, 230, 230);
pub const COLOR_LIGHT_BLUE: Color = Color::Rgb(138, 196, 255);
pub const COLOR_YELLOW: Color = Color::Rgb(249, 229, 113);
pub const COLOR_GREEN: Color = Color::Rgb(72, 213, 150);
pub const COLOR_RED: Color = Color::Rgb(249, 167, 164);
pub const COLOR_ORANGE: Color = Color::Rgb(255, 170, 66);
pub const COLOR_WHITE: Color = Color::Rgb(255, 255, 255);
pub const COLOR_MAGENTA: Color = Color::Rgb(199, 146, 234);
pub const COLOR_DARK_GRAY: Color = Color::Rgb(50, 50, 50);
// light theme colors
pub const COLOR_MAGENTA_DARK: Color = Color::Rgb(153, 26, 237);
pub const COLOR_GRAY: Color = Color::Rgb(91, 87, 87);
pub const COLOR_BLUE: Color = Color::Rgb(0, 82, 163);
pub const COLOR_GREEN_DARK: Color = Color::Rgb(20, 97, 73);
pub const COLOR_RED_DARK: Color = Color::Rgb(173, 25, 20);
pub const COLOR_ORANGE_DARK: Color = Color::Rgb(184, 49, 15);
// YAML background colors
const YAML_BACKGROUND_LIGHT: syntect::highlighting::Color = syntect::highlighting::Color::WHITE;
const YAML_BACKGROUND_DARK: syntect::highlighting::Color = syntect::highlighting::Color {
  r: 35,
  g: 50,
  b: 55,
  a: 255,
}; // corresponds to TEAL

/// Convert a syntect highlight segment into an owned ratatui Span.
fn syntect_to_ratatui_span_owned(
  (style, content): (syntect::highlighting::Style, &str),
) -> Option<Span<'static>> {
  use syntect::highlighting::FontStyle;
  let fg = if style.foreground.a > 0 {
    Some(Color::Rgb(
      style.foreground.r,
      style.foreground.g,
      style.foreground.b,
    ))
  } else {
    None
  };
  let bg = if style.background.a > 0 {
    Some(Color::Rgb(
      style.background.r,
      style.background.g,
      style.background.b,
    ))
  } else {
    None
  };
  let modifier = {
    let fs = style.font_style;
    let mut m = Modifier::empty();
    if fs.contains(FontStyle::BOLD) {
      m |= Modifier::BOLD;
    }
    if fs.contains(FontStyle::ITALIC) {
      m |= Modifier::ITALIC;
    }
    if fs.contains(FontStyle::UNDERLINE) {
      m |= Modifier::UNDERLINED;
    }
    m
  };
  let ratatui_style = Style::default()
    .fg(fg.unwrap_or_default())
    .bg(bg.unwrap_or_default())
    .add_modifier(modifier);
  Some(Span::styled(content.to_owned(), ratatui_style))
}

fn get_syntax_set() -> &'static syntect::parsing::SyntaxSet {
  static SYNTAX_SET: OnceLock<syntect::parsing::SyntaxSet> = OnceLock::new();
  SYNTAX_SET.get_or_init(syntect::parsing::SyntaxSet::load_defaults_newlines)
}

fn get_yaml_syntax_reference() -> &'static syntect::parsing::SyntaxReference {
  static YAML_SYNTAX_REFERENCE: OnceLock<syntect::parsing::SyntaxReference> = OnceLock::new();
  YAML_SYNTAX_REFERENCE.get_or_init(|| {
    get_syntax_set()
      .find_syntax_by_extension("yaml")
      .unwrap()
      .clone()
  })
}

struct YamlThemes {
  dark: syntect::highlighting::Theme,
  light: syntect::highlighting::Theme,
}

fn get_yaml_themes() -> &'static YamlThemes {
  static YAML_THEMES: OnceLock<YamlThemes> = OnceLock::new();
  YAML_THEMES.get_or_init(|| {
    let ts = syntect::highlighting::ThemeSet::load_defaults();
    let mut dark = ts.themes["Solarized (dark)"].clone();
    dark.settings.background = Some(YAML_BACKGROUND_DARK);
    let mut light = ts.themes["Solarized (light)"].clone();
    light.settings.background = Some(YAML_BACKGROUND_LIGHT);
    YamlThemes { dark, light }
  })
}

#[derive(Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum Styles {
  Default,
  Header,
  Logo,
  Failure,
  Warning,
  Success,
  Primary,
  Secondary,
  Help,
  Background,
}

pub fn theme_styles(light: bool) -> BTreeMap<Styles, Style> {
  if light {
    BTreeMap::from([
      (Styles::Default, Style::default().fg(COLOR_GRAY)),
      (Styles::Header, Style::default().fg(COLOR_DARK_GRAY)),
      (Styles::Logo, Style::default().fg(COLOR_GREEN_DARK)),
      (Styles::Failure, Style::default().fg(COLOR_RED_DARK)),
      (Styles::Warning, Style::default().fg(COLOR_ORANGE_DARK)),
      (Styles::Success, Style::default().fg(COLOR_GREEN_DARK)),
      (Styles::Primary, Style::default().fg(COLOR_BLUE)),
      (Styles::Secondary, Style::default().fg(COLOR_MAGENTA_DARK)),
      (Styles::Help, Style::default().fg(COLOR_BLUE)),
      (
        Styles::Background,
        Style::default().bg(COLOR_WHITE).fg(COLOR_GRAY),
      ),
    ])
  } else {
    BTreeMap::from([
      (Styles::Default, Style::default().fg(COLOR_WHITE)),
      (Styles::Header, Style::default().fg(COLOR_DARK_GRAY)),
      (Styles::Logo, Style::default().fg(COLOR_GREEN)),
      (Styles::Failure, Style::default().fg(COLOR_RED)),
      (Styles::Warning, Style::default().fg(COLOR_ORANGE)),
      (Styles::Success, Style::default().fg(COLOR_GREEN)),
      (Styles::Primary, Style::default().fg(COLOR_CYAN)),
      (Styles::Secondary, Style::default().fg(COLOR_YELLOW)),
      (Styles::Help, Style::default().fg(COLOR_LIGHT_BLUE)),
      (
        Styles::Background,
        Style::default().bg(COLOR_TEAL).fg(COLOR_WHITE),
      ),
    ])
  }
}

pub fn title_style(txt: &str) -> Span<'_> {
  Span::styled(txt, style_bold())
}

pub fn style_header_text(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Header).unwrap()
}

pub fn style_header() -> Style {
  Style::default().bg(COLOR_MAGENTA)
}

pub fn style_bold() -> Style {
  Style::default().add_modifier(Modifier::BOLD)
}

pub fn style_default(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Default).unwrap()
}
pub fn style_logo(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Logo).unwrap()
}
pub fn style_failure(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Failure).unwrap()
}
pub fn style_warning(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Warning).unwrap()
}
pub fn style_success(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Success).unwrap()
}
pub fn style_primary(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Primary).unwrap()
}
pub fn style_help(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Help).unwrap()
}

pub fn style_secondary(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Secondary).unwrap()
}

pub fn style_main_background(light: bool) -> Style {
  *theme_styles(light).get(&Styles::Background).unwrap()
}

pub fn style_highlight() -> Style {
  Style::default().add_modifier(Modifier::REVERSED)
}

pub fn get_gauge_symbol(enhanced_graphics: bool) -> &'static str {
  if enhanced_graphics {
    symbols::line::THICK_HORIZONTAL
  } else {
    symbols::line::HORIZONTAL
  }
}

pub fn table_header_style(cells: Vec<&str>, light: bool) -> Row<'_> {
  Row::new(cells).style(style_default(light)).bottom_margin(0)
}

pub fn horizontal_chunks(constraints: Vec<Constraint>, size: Rect) -> Rc<[Rect]> {
  Layout::default()
    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
      &constraints,
    ))
    .direction(Direction::Horizontal)
    .split(size)
}

pub fn horizontal_chunks_with_margin(
  constraints: Vec<Constraint>,
  size: Rect,
  margin: u16,
) -> Rc<[Rect]> {
  Layout::default()
    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
      &constraints,
    ))
    .direction(Direction::Horizontal)
    .margin(margin)
    .split(size)
}

pub fn vertical_chunks(constraints: Vec<Constraint>, size: Rect) -> Rc<[Rect]> {
  Layout::default()
    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
      &constraints,
    ))
    .direction(Direction::Vertical)
    .split(size)
}

pub fn vertical_chunks_with_margin(
  constraints: Vec<Constraint>,
  size: Rect,
  margin: u16,
) -> Rc<[Rect]> {
  Layout::default()
    .constraints(<Vec<Constraint> as AsRef<[Constraint]>>::as_ref(
      &constraints,
    ))
    .direction(Direction::Vertical)
    .margin(margin)
    .split(size)
}

pub fn layout_block(title: Span<'_>) -> Block<'_> {
  Block::default().borders(Borders::ALL).title(title)
}

pub fn layout_block_default(title: &str) -> Block<'_> {
  layout_block(title_style(title))
}

pub fn layout_block_active(title: &str, light: bool) -> Block<'_> {
  layout_block(title_style(title)).style(style_secondary(light))
}

pub fn layout_block_active_span(title: Line<'_>, light: bool) -> Block<'_> {
  Block::default()
    .borders(Borders::ALL)
    .title(title)
    .style(style_secondary(light))
}

pub fn layout_block_top_border(title: Line<'_>) -> Block<'_> {
  Block::default().borders(Borders::TOP).title(title)
}

enum FilterDisplayState<'a> {
  Inactive,
  EditingEmpty,
  Value { filter: &'a str, active: bool },
}

fn filter_display_state(filter: &str, active: bool) -> FilterDisplayState<'_> {
  if active && filter.is_empty() {
    FilterDisplayState::EditingEmpty
  } else if !filter.is_empty() {
    FilterDisplayState::Value { filter, active }
  } else {
    FilterDisplayState::Inactive
  }
}

pub fn filter_status_hint(filter: &str, active: bool) -> String {
  match filter_display_state(filter, active) {
    FilterDisplayState::Inactive => "filter < / >".to_string(),
    FilterDisplayState::EditingEmpty => "type to filter | clear <esc>".to_string(),
    FilterDisplayState::Value {
      filter,
      active: true,
    } => format!("[{}] | clear <esc>", filter),
    FilterDisplayState::Value {
      filter,
      active: false,
    } => format!("[{}] | edit < / >", filter),
  }
}

pub fn filter_bar_title<'a>(filter: &'a str, active: bool, light: bool) -> Line<'a> {
  match filter_display_state(filter, active) {
    FilterDisplayState::Inactive => {
      Line::from(vec![Span::styled(" filter < / > ", style_secondary(light))])
    }
    FilterDisplayState::EditingEmpty => Line::from(vec![
      Span::styled(" / ", style_secondary(light)),
      Span::styled("type to filter", style_default(light)),
      Span::styled("  | clear <esc> ", style_secondary(light)),
    ]),
    FilterDisplayState::Value {
      filter,
      active: true,
    } => Line::from(vec![
      Span::styled(" / ", style_secondary(light)),
      Span::styled(filter, style_default(light)),
      Span::styled("  | clear <esc> ", style_secondary(light)),
    ]),
    FilterDisplayState::Value {
      filter,
      active: false,
    } => Line::from(vec![
      Span::styled(" / ", style_secondary(light)),
      Span::styled(filter, style_default(light)),
      Span::styled("  | edit < / > ", style_secondary(light)),
    ]),
  }
}

pub fn title_with_dual_style<'a>(part_1: String, part_2: String, light: bool) -> Line<'a> {
  Line::from(vec![
    Span::styled(part_1, style_secondary(light).add_modifier(Modifier::BOLD)),
    Span::styled(part_2, style_default(light).add_modifier(Modifier::BOLD)),
  ])
}

/// helper function to create a centered rect using up
/// certain percentage of the available rect `r`
pub fn centered_rect(width: u16, height: u16, r: Rect) -> Rect {
  let Rect {
    width: grid_width,
    height: grid_height,
    ..
  } = r;
  let outer_height = (grid_height / 2).saturating_sub(height / 2);

  let popup_layout = Layout::default()
    .direction(Direction::Vertical)
    .constraints(
      [
        Constraint::Length(outer_height),
        Constraint::Length(height),
        Constraint::Length(outer_height),
      ]
      .as_ref(),
    )
    .split(r);

  let outer_width = (grid_width / 2).saturating_sub(width / 2);

  Layout::default()
    .direction(Direction::Horizontal)
    .constraints(
      [
        Constraint::Length(outer_width),
        Constraint::Length(width),
        Constraint::Length(outer_width),
      ]
      .as_ref(),
    )
    .split(popup_layout[1])[1]
}

pub fn loading(f: &mut Frame<'_>, block: Block<'_>, area: Rect, is_loading: bool, light: bool) {
  if is_loading {
    let text = "\n\n Loading ...\n\n".to_owned();
    let text = Text::from(text);
    let text = text.patch_style(style_secondary(light));

    // Contains the text
    let paragraph = Paragraph::new(text)
      .style(style_secondary(light))
      .block(block);
    f.render_widget(paragraph, area);
  } else {
    f.render_widget(block, area)
  }
}

// using a macro to reuse code as generics will make handling lifetimes a PITA
#[macro_export]
macro_rules! draw_resource_tab {
  ($title:expr, $block:expr, $f:expr, $app:expr, $area:expr, $fn1:expr, $fn2:expr, $res:expr) => {
    match $block {
      ActiveBlock::Describe => draw_describe_block(
        $f,
        $app,
        $area,
        title_with_dual_style(
          get_resource_title($app, $title, get_describe_active($block), $res.items.len()),
          format!("{} | {} <esc> ", COPY_HINT, $title),
          $app.light_theme,
        ),
      ),
      ActiveBlock::Yaml => draw_yaml_block(
        $f,
        $app,
        $area,
        title_with_dual_style(
          get_resource_title($app, $title, get_describe_active($block), $res.items.len()),
          format!("{} | {} <esc> ", COPY_HINT, $title),
          $app.light_theme,
        ),
      ),
      ActiveBlock::Pods => $crate::app::pods::draw_block_as_sub($f, $app, $area),
      ActiveBlock::Containers => $crate::app::pods::draw_containers_block($f, $app, $area),
      ActiveBlock::Logs => $crate::app::pods::draw_logs_block($f, $app, $area),
      ActiveBlock::Namespaces => $fn1($app.get_prev_route().active_block, $f, $app, $area),
      _ => $fn2($f, $app, $area),
    };
  };
}

pub struct ResourceTableProps<'a, T> {
  pub title: String,
  pub inline_help: String,
  pub resource: &'a mut StatefulTable<T>,
  pub table_headers: Vec<&'a str>,
  pub column_widths: Vec<Constraint>,
}
/// common for all resources
pub fn draw_describe_block(f: &mut Frame<'_>, app: &mut App, area: Rect, title: Line<'_>) {
  draw_yaml_block(f, app, area, title);
}

/// common for all resources
pub fn draw_yaml_block(f: &mut Frame<'_>, app: &mut App, area: Rect, title: Line<'_>) {
  let block = layout_block_top_border(title);

  let txt = app.data.describe_out.get_txt();
  if !txt.is_empty() {
    // Re-highlight only when the cache is empty or the theme changed.
    if app.data.describe_out.highlighted_lines.is_empty()
      || app.data.describe_out.highlight_light_theme != app.light_theme
    {
      let ss = get_syntax_set();
      let syntax = get_yaml_syntax_reference();
      let theme = if app.light_theme {
        &get_yaml_themes().light
      } else {
        &get_yaml_themes().dark
      };
      let mut h = syntect::easy::HighlightLines::new(syntax, theme);
      let lines: Vec<_> = syntect::util::LinesWithEndings::from(txt)
        .filter_map(|line| match h.highlight_line(line, ss) {
          Ok(segments) => {
            let line_spans: Vec<_> = segments
              .into_iter()
              .filter_map(syntect_to_ratatui_span_owned)
              .collect();
            Some(ratatui::text::Line::from(line_spans))
          }
          Err(_) => None,
        })
        .collect();
      app.data.describe_out.highlighted_lines = lines;
      app.data.describe_out.highlight_light_theme = app.light_theme;
    }

    let paragraph = Paragraph::new(app.data.describe_out.highlighted_lines.clone())
      .block(block)
      .wrap(Wrap { trim: false })
      .scroll((
        app.data.describe_out.offset.min(u16::MAX as usize) as u16,
        0,
      ));
    f.render_widget(paragraph, area);
  } else {
    loading(f, block, area, app.is_loading(), app.light_theme);
  }
}

/// Draw a kubernetes resource overview tab
pub fn draw_resource_block<'a, T: KubeResource<U>, F, U: Serialize>(
  f: &mut Frame<'_>,
  area: Rect,
  table_props: ResourceTableProps<'a, T>,
  row_cell_mapper: F,
  light_theme: bool,
  is_loading: bool,
) where
  F: Fn(&T) -> Row<'a>,
{
  let title = title_with_dual_style(table_props.title, table_props.inline_help, light_theme);
  let block = layout_block_top_border(title);

  if !table_props.resource.items.is_empty() {
    let filter = table_props.resource.filter.to_lowercase();
    // Build filtered rows and track the mapping from visible index → items index.
    let has_filter = !filter.is_empty();
    let mut filtered_indices: Vec<usize> = Vec::new();
    let rows: Vec<Row<'a>> = table_props
      .resource
      .items
      .iter()
      .enumerate()
      .filter_map(|(idx, c)| {
        let mapper = row_cell_mapper(c);
        if filter.is_empty() || filter_by_name(&filter, c) {
          Some((idx, mapper))
        } else {
          None
        }
      })
      .map(|(idx, row)| {
        if has_filter {
          filtered_indices.push(idx);
        }
        row
      })
      .collect();

    // Clamp selection to the filtered list length.
    if has_filter {
      let max = filtered_indices.len().saturating_sub(1);
      if let Some(sel) = table_props.resource.state.selected() {
        if sel > max {
          table_props.resource.state.select(Some(max));
        }
      }
    }
    table_props.resource.filtered_indices = filtered_indices;

    let table = Table::new(rows, &table_props.column_widths)
      .header(table_header_style(table_props.table_headers, light_theme))
      .block(block)
      .row_highlight_style(style_highlight())
      .highlight_symbol(HIGHLIGHT);

    f.render_stateful_widget(table, area, &mut table_props.resource.state);
  } else {
    loading(f, block, area, is_loading, light_theme);
  }
}

pub fn filter_by_resource_name<T: KubeResource<U>, U: Serialize>(
  filter: &str,
  res: &T,
  row_cell_mapper: Row<'static>,
) -> Option<Row<'static>> {
  if filter.is_empty() || filter_by_name(filter, res) {
    Some(row_cell_mapper)
  } else {
    None
  }
}

pub fn text_matches_filter(filter: &str, value: &str) -> bool {
  let filter = filter.to_lowercase();
  let value = value.to_lowercase();
  filter.is_empty() || glob_match(&filter, &value) || value.contains(&filter)
}

fn filter_by_name<T: KubeResource<U>, U: Serialize>(ft: &str, res: &T) -> bool {
  text_matches_filter(ft, res.get_name())
}

pub fn get_cluster_wide_resource_title<S: AsRef<str>>(
  title: S,
  items_len: usize,
  suffix: S,
) -> String {
  format!(" {} [{}] {}", title.as_ref(), items_len, suffix.as_ref())
}

pub fn get_resource_title<S: AsRef<str>>(
  app: &App,
  title: S,
  suffix: S,
  items_len: usize,
) -> String {
  format!(
    " {} {}",
    title_with_ns(
      title.as_ref(),
      app
        .data
        .selected
        .ns
        .as_ref()
        .unwrap_or(&String::from("all")),
      items_len
    ),
    suffix.as_ref(),
  )
}

static DESCRIBE_ACTIVE: &str = "-> Describe ";
static YAML_ACTIVE: &str = "-> YAML ";

pub fn get_describe_active<'a>(block: ActiveBlock) -> &'a str {
  match block {
    ActiveBlock::Describe => DESCRIBE_ACTIVE,
    _ => YAML_ACTIVE,
  }
}

pub fn title_with_ns(title: &str, ns: &str, length: usize) -> String {
  format!("{} (ns: {}) [{}]", title, ns, length)
}

#[cfg(test)]
mod tests {
  use ratatui::{
    backend::TestBackend, buffer::Buffer, layout::Position, style::Modifier, widgets::Cell,
    Terminal,
  };

  use super::*;
  use crate::ui::utils::{COLOR_CYAN, COLOR_WHITE, COLOR_YELLOW};

  #[test]
  fn test_draw_resource_block() {
    let backend = TestBackend::new(100, 6);
    let mut terminal = Terminal::new(backend).unwrap();

    struct RenderTest {
      pub name: String,
      pub namespace: String,
      pub data: i32,
      pub age: String,
    }

    impl KubeResource<Option<String>> for RenderTest {
      fn get_name(&self) -> &String {
        &self.name
      }
      fn get_k8s_obj(&self) -> &Option<String> {
        &None
      }
    }
    terminal
      .draw(|f| {
        let size = f.area();
        let mut resource: StatefulTable<RenderTest> = StatefulTable::new();
        resource.set_items(vec![
          RenderTest {
            name: "Test 1".into(),
            namespace: "Test ns".into(),
            age: "65h3m".into(),
            data: 5,
          },
          RenderTest {
            name: "Test long name that should be truncated from view".into(),
            namespace: "Test ns".into(),
            age: "65h3m".into(),
            data: 3,
          },
          RenderTest {
            name: "test_long_name_that_should_be_truncated_from_view".into(),
            namespace: "Test ns long value check that should be truncated".into(),
            age: "65h3m".into(),
            data: 6,
          },
        ]);
        draw_resource_block(
          f,
          size,
          ResourceTableProps {
            title: "Test".into(),
            inline_help: "-> yaml <y>".into(),
            resource: &mut resource,
            table_headers: vec!["Namespace", "Name", "Data", "Age"],
            column_widths: vec![
              Constraint::Percentage(30),
              Constraint::Percentage(40),
              Constraint::Percentage(15),
              Constraint::Percentage(15),
            ],
          },
          |c| {
            Row::new(vec![
              Cell::from(c.namespace.to_owned()),
              Cell::from(c.name.to_owned()),
              Cell::from(c.data.to_string()),
              Cell::from(c.age.to_owned()),
            ])
            .style(style_primary(false))
          },
          false,
          false,
        );
      })
      .unwrap();

    let mut expected = Buffer::with_lines(vec![
        "Test-> yaml <y>─────────────────────────────────────────────────────────────────────────────────────",
        "   Namespace                     Name                                 Data           Age            ",
        "=> Test ns                       Test 1                               5              65h3m          ",
        "   Test ns                       Test long name that should be trunca 3              65h3m          ",
        "   Test ns long value check that test_long_name_that_should_be_trunca 6              65h3m          ",
        "                                                                                                    ",
      ]);
    // set row styles
    // First row heading style
    for col in 0..=99 {
      match col {
        0..=3 => {
          expected.cell_mut(Position::new(col, 0)).unwrap().set_style(
            Style::default()
              .fg(COLOR_YELLOW)
              .add_modifier(Modifier::BOLD),
          );
        }
        4..=14 => {
          expected.cell_mut(Position::new(col, 0)).unwrap().set_style(
            Style::default()
              .fg(COLOR_WHITE)
              .add_modifier(Modifier::BOLD),
          );
        }
        _ => {}
      }
    }

    // Second row table header style
    for col in 0..=99 {
      expected
        .cell_mut(Position::new(col, 1))
        .unwrap()
        .set_style(Style::default().fg(COLOR_WHITE));
    }
    // first table data row style
    for col in 0..=99 {
      expected.cell_mut(Position::new(col, 2)).unwrap().set_style(
        Style::default()
          .fg(COLOR_CYAN)
          .add_modifier(Modifier::REVERSED),
      );
    }
    // remaining table data row style
    for row in 3..=4 {
      for col in 0..=99 {
        expected
          .cell_mut(Position::new(col, row))
          .unwrap()
          .set_style(Style::default().fg(COLOR_CYAN));
      }
    }

    terminal.backend().assert_buffer(&expected);
  }

  #[test]
  fn test_draw_resource_block_filter() {
    let backend = TestBackend::new(100, 6);
    let mut terminal = Terminal::new(backend).unwrap();

    struct RenderTest {
      pub name: String,
      pub namespace: String,
      pub data: i32,
      pub age: String,
    }
    impl KubeResource<Option<String>> for RenderTest {
      fn get_name(&self) -> &String {
        &self.name
      }
      fn get_k8s_obj(&self) -> &Option<String> {
        &None
      }
    }

    terminal
      .draw(|f| {
        let size = f.area();
        let mut resource: StatefulTable<RenderTest> = StatefulTable::new();
        resource.set_items(vec![
          RenderTest {
            name: "Test 1".into(),
            namespace: "Test ns".into(),
            age: "65h3m".into(),
            data: 5,
          },
          RenderTest {
            name: "Test long name that should be truncated from view".into(),
            namespace: "Test ns".into(),
            age: "65h3m".into(),
            data: 3,
          },
          RenderTest {
            name: "test_long_name_that_should_be_truncated_from_view".into(),
            namespace: "Test ns long value check that should be truncated".into(),
            age: "65h3m".into(),
            data: 6,
          },
        ]);
        resource.filter = "truncated".to_string();
        draw_resource_block(
          f,
          size,
          ResourceTableProps {
            title: "Test".into(),
            inline_help: "-> yaml <y>".into(),
            resource: &mut resource,
            table_headers: vec!["Namespace", "Name", "Data", "Age"],
            column_widths: vec![
              Constraint::Percentage(30),
              Constraint::Percentage(40),
              Constraint::Percentage(15),
              Constraint::Percentage(15),
            ],
          },
          |c| {
            Row::new(vec![
              Cell::from(c.namespace.to_owned()),
              Cell::from(c.name.to_owned()),
              Cell::from(c.data.to_string()),
              Cell::from(c.age.to_owned()),
            ])
            .style(style_primary(false))
          },
          false,
          false,
        );
      })
      .unwrap();

    let mut expected = Buffer::with_lines(vec![
        "Test-> yaml <y>─────────────────────────────────────────────────────────────────────────────────────",
        "   Namespace                     Name                                 Data           Age            ",
        "=> Test ns                       Test long name that should be trunca 3              65h3m          ",
        "   Test ns long value check that test_long_name_that_should_be_trunca 6              65h3m          ",
        "                                                                                                    ",
        "                                                                                                    ",
      ]);
    // set row styles
    // First row heading style
    for col in 0..=99 {
      match col {
        0..=3 => {
          expected.cell_mut(Position::new(col, 0)).unwrap().set_style(
            Style::default()
              .fg(COLOR_YELLOW)
              .add_modifier(Modifier::BOLD),
          );
        }
        4..=14 => {
          expected.cell_mut(Position::new(col, 0)).unwrap().set_style(
            Style::default()
              .fg(COLOR_WHITE)
              .add_modifier(Modifier::BOLD),
          );
        }
        _ => {}
      }
    }

    // Second row table header style
    for col in 0..=99 {
      expected
        .cell_mut(Position::new(col, 1))
        .unwrap()
        .set_style(Style::default().fg(COLOR_WHITE));
    }
    // first table data row style
    for col in 0..=99 {
      expected.cell_mut(Position::new(col, 2)).unwrap().set_style(
        Style::default()
          .fg(COLOR_CYAN)
          .add_modifier(Modifier::REVERSED),
      );
    }
    // remaining table data row style
    for row in 3..=3 {
      for col in 0..=99 {
        expected
          .cell_mut(Position::new(col, row))
          .unwrap()
          .set_style(Style::default().fg(COLOR_CYAN));
      }
    }

    terminal.backend().assert_buffer(&expected);
  }

  #[test]
  fn test_draw_resource_block_filter_glob() {
    let backend = TestBackend::new(100, 6);
    let mut terminal = Terminal::new(backend).unwrap();

    struct RenderTest {
      pub name: String,
      pub namespace: String,
      pub data: i32,
      pub age: String,
    }
    impl KubeResource<Option<String>> for RenderTest {
      fn get_name(&self) -> &String {
        &self.name
      }
      fn get_k8s_obj(&self) -> &Option<String> {
        &None
      }
    }

    terminal
      .draw(|f| {
        let size = f.area();
        let mut resource: StatefulTable<RenderTest> = StatefulTable::new();
        resource.set_items(vec![
          RenderTest {
            name: "Test 1".into(),
            namespace: "Test ns".into(),
            age: "65h3m".into(),
            data: 5,
          },
          RenderTest {
            name: "Test long name that should be truncated from view".into(),
            namespace: "Test ns".into(),
            age: "65h3m".into(),
            data: 3,
          },
          RenderTest {
            name: "test_long_name_that_should_be_truncated_from_view".into(),
            namespace: "Test ns long value check that should be truncated".into(),
            age: "65h3m".into(),
            data: 6,
          },
        ]);
        resource.filter = "*long*truncated*".to_string();
        draw_resource_block(
          f,
          size,
          ResourceTableProps {
            title: "Test".into(),
            inline_help: "-> yaml <y>".into(),
            resource: &mut resource,
            table_headers: vec!["Namespace", "Name", "Data", "Age"],
            column_widths: vec![
              Constraint::Percentage(30),
              Constraint::Percentage(40),
              Constraint::Percentage(15),
              Constraint::Percentage(15),
            ],
          },
          |c| {
            Row::new(vec![
              Cell::from(c.namespace.to_owned()),
              Cell::from(c.name.to_owned()),
              Cell::from(c.data.to_string()),
              Cell::from(c.age.to_owned()),
            ])
            .style(style_primary(false))
          },
          false,
          false,
        );
      })
      .unwrap();

    let mut expected = Buffer::with_lines(vec![
        "Test-> yaml <y>─────────────────────────────────────────────────────────────────────────────────────",
        "   Namespace                     Name                                 Data           Age            ",
        "=> Test ns                       Test long name that should be trunca 3              65h3m          ",
        "   Test ns long value check that test_long_name_that_should_be_trunca 6              65h3m          ",
        "                                                                                                    ",
        "                                                                                                    ",
      ]);
    // set row styles
    // First row heading style
    for col in 0..=99 {
      match col {
        0..=3 => {
          expected.cell_mut(Position::new(col, 0)).unwrap().set_style(
            Style::default()
              .fg(COLOR_YELLOW)
              .add_modifier(Modifier::BOLD),
          );
        }
        4..=14 => {
          expected.cell_mut(Position::new(col, 0)).unwrap().set_style(
            Style::default()
              .fg(COLOR_WHITE)
              .add_modifier(Modifier::BOLD),
          );
        }
        _ => {}
      }
    }

    // Second row table header style
    for col in 0..=99 {
      expected
        .cell_mut(Position::new(col, 1))
        .unwrap()
        .set_style(Style::default().fg(COLOR_WHITE));
    }
    // first table data row style
    for col in 0..=99 {
      expected.cell_mut(Position::new(col, 2)).unwrap().set_style(
        Style::default()
          .fg(COLOR_CYAN)
          .add_modifier(Modifier::REVERSED),
      );
    }
    // remaining table data row style
    for row in 3..=3 {
      for col in 0..=99 {
        expected
          .cell_mut(Position::new(col, row))
          .unwrap()
          .set_style(Style::default().fg(COLOR_CYAN));
      }
    }

    terminal.backend().assert_buffer(&expected);
  }

  #[test]
  fn test_get_resource_title() {
    let app = App::default();
    assert_eq!(
      get_resource_title(&app, "Title", "-> hello", 5),
      " Title (ns: all) [5] -> hello"
    );
  }

  #[test]
  fn test_title_with_ns() {
    assert_eq!(title_with_ns("Title", "hello", 3), "Title (ns: hello) [3]");
  }

  #[test]
  fn test_get_cluster_wide_resource_title() {
    assert_eq!(
      get_cluster_wide_resource_title("Cluster Resource", 3, ""),
      " Cluster Resource [3] "
    );
    assert_eq!(
      get_cluster_wide_resource_title("Nodes", 10, "-> hello"),
      " Nodes [10] -> hello"
    );
  }
}

kdash-rs / kdash / 24024608060

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous