122 lines
3.8 KiB
Rust
122 lines
3.8 KiB
Rust
use anyhow::{anyhow, Context, Result};
|
|
use clap::*;
|
|
use is_terminal::IsTerminal;
|
|
use std::path::PathBuf;
|
|
use strum::IntoEnumIterator;
|
|
|
|
use crate::compression::default_type;
|
|
use crate::compression::program::CompressionEngineProgram;
|
|
use crate::compression::CompressionType;
|
|
use crate::compression::COMPRESSION_PROGRAMS;
|
|
use std::str::FromStr;
|
|
|
|
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};
|
|
|
|
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 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"));
|
|
|
|
let default_type = match args.item.compression {
|
|
Some(compression_name) => FromStr::from_str(&compression_name)
|
|
.context(anyhow!("Invalid compression type {}", compression_name))?,
|
|
None => default_type(),
|
|
};
|
|
|
|
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.eq("") {
|
|
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(" ")),
|
|
]));
|
|
}
|
|
|
|
println!("PATHS:");
|
|
path_table.printstd();
|
|
println!();
|
|
println!("COMPRESSION:");
|
|
compression_table.printstd();
|
|
|
|
Ok(())
|
|
}
|