keep/src/modes/status.rs

use clap::*;
use is_terminal::IsTerminal;
use std::path::PathBuf;
use strum::IntoEnumIterator;

use crate::compression_engine::default_type;
use crate::compression_engine::program::CompressionEngineProgram;
use crate::compression_engine::CompressionType;
use crate::compression_engine::COMPRESSION_PROGRAMS;

use crate::FORMAT_BOX_CHARS_NO_BORDER_LINE_SEPARATOR;
use crate::FORMAT_NO_BORDER_LINE_SEPARATOR;
use prettytable::color;
use prettytable::row;
use prettytable::{Attr, Cell, Row, Table};

fn build_path_table(data_path: PathBuf, db_path: PathBuf) -> Table {
    let mut path_table = Table::new();

    if std::io::stdout().is_terminal() {
        path_table.set_format(*FORMAT_BOX_CHARS_NO_BORDER_LINE_SEPARATOR);
    } else {
        path_table.set_format(*FORMAT_NO_BORDER_LINE_SEPARATOR);
    }

    path_table.set_titles(Row::new(vec![
        Cell::new("Type").with_style(Attr::Bold),
        Cell::new("Path").with_style(Attr::Bold),
    ]));

    path_table.add_row(Row::new(vec![
        Cell::new("Data"),
        Cell::new(
            &data_path
                .into_os_string()
                .into_string()
                .expect("Unable to convert data path to string"),
        ),
    ]));

    path_table.add_row(Row::new(vec![
        Cell::new("Database"),
        Cell::new(
            &db_path
                .into_os_string()
                .into_string()
                .expect("Unable to convert DB path to string"),
        ),
    ]));

    path_table
}

fn build_compression_table(_args: crate::Args, default_type: CompressionType) -> Table {
    let mut compression_table = Table::new();
    if std::io::stdout().is_terminal() {
        compression_table.set_format(*FORMAT_BOX_CHARS_NO_BORDER_LINE_SEPARATOR);
    } else {
        compression_table.set_format(*FORMAT_NO_BORDER_LINE_SEPARATOR);
    }

    compression_table.set_titles(row!(
        b->"Type",
        b->"Found",
        b->"Default",
        b->"Binary",
        b->"Compress",
        b->"Decompress"));

    for compression_type in CompressionType::iter() {
        let compression_program: CompressionEngineProgram =
            match &COMPRESSION_PROGRAMS[compression_type.clone()] {
                Some(compression_program) => compression_program.clone(),
                None => CompressionEngineProgram {
                    program: "".to_string(),
                    compress: Vec::new(),
                    decompress: Vec::new(),
                    supported: true,
                },
            };

        let is_default = compression_type == default_type;

        compression_table.add_row(Row::new(vec![
            Cell::new(&compression_type.to_string()),
            match compression_program.supported {
                true => Cell::new("Yes").with_style(Attr::ForegroundColor(color::GREEN)),
                false => Cell::new("No").with_style(Attr::ForegroundColor(color::RED)),
            },
            match is_default {
                true => Cell::new("Yes").with_style(Attr::ForegroundColor(color::GREEN)),
                false => Cell::new("No"),
            },
            match compression_program.program.is_empty() {
                true => {
                    Cell::new("<INTERNAL>").with_style(Attr::ForegroundColor(color::BRIGHT_BLACK))
                }
                false => Cell::new(&compression_program.program),
            },
            Cell::new(&compression_program.compress.join(" ")),
            Cell::new(&compression_program.decompress.join(" ")),
        ]));
    }

    compression_table
}

pub fn mode_status(
    _cmd: &mut Command,
    args: crate::Args,
    data_path: PathBuf,
    db_path: PathBuf,
) -> Result<()> {
    let mut path_table = Table::new();

    if std::io::stdout().is_terminal() {
        path_table.set_format(*FORMAT_BOX_CHARS_NO_BORDER_LINE_SEPARATOR);
    } else {
        path_table.set_format(*FORMAT_NO_BORDER_LINE_SEPARATOR);
    }

    path_table.set_titles(Row::new(vec![
        Cell::new("Type").with_style(Attr::Bold),
        Cell::new("Path").with_style(Attr::Bold),
    ]));

    path_table.add_row(Row::new(vec![
        Cell::new("Data"),
        Cell::new(
            &data_path
                .into_os_string()
                .into_string()
                .expect("Unable to convert data path to string"),
        ),
    ]));

    path_table.add_row(Row::new(vec![
        Cell::new("Database"),
        Cell::new(
            &db_path
                .into_os_string()
                .into_string()
                .expect("Unable to convert DB path to string"),
        ),
    ]));

    let compression_table = build_compression_table(args, default_type());
    let path_table = build_path_table(data_path, db_path);

    println!("PATHS:");
    path_table.printstd();
    println!();
    println!("COMPRESSION:");
    compression_table.printstd();

    Ok(())
}