lsd/src/display.rs

656 lines
20 KiB
Rust
Raw Normal View History

use crate::color::{Colors, Elem};
2019-10-24 15:18:42 +00:00
use crate::flags::{Block, Display, Flags, Layout};
2019-02-09 10:41:42 +00:00
use crate::icon::Icons;
2020-02-02 14:32:40 +00:00
use crate::meta::name::DisplayOption;
2020-02-04 04:32:36 +00:00
use crate::meta::{FileType, Meta};
use std::collections::HashMap;
2018-12-02 16:22:51 +00:00
use term_grid::{Cell, Direction, Filling, Grid, GridOptions};
use terminal_size::terminal_size;
use unicode_width::UnicodeWidthStr;
2018-12-02 16:22:51 +00:00
2018-12-13 15:50:47 +00:00
const EDGE: &str = "\u{251c}\u{2500}\u{2500}"; // "├──"
const LINE: &str = "\u{2502} "; // "│ "
2018-12-13 15:50:47 +00:00
const CORNER: &str = "\u{2514}\u{2500}\u{2500}"; // "└──"
2019-01-23 17:02:36 +00:00
const BLANK: &str = " ";
2018-12-04 13:54:56 +00:00
2019-10-23 15:26:39 +00:00
pub fn grid(metas: &[Meta], flags: &Flags, colors: &Colors, icons: &Icons) -> String {
let term_width = terminal_size().map(|(w, _)| w.0 as usize);
2019-01-20 10:22:14 +00:00
2020-02-04 04:32:36 +00:00
inner_display_grid(
&DisplayOption::None,
2020-02-04 04:32:36 +00:00
metas,
flags,
2020-02-04 04:32:36 +00:00
colors,
icons,
0,
term_width,
)
2019-01-20 10:22:14 +00:00
}
2019-10-23 15:26:39 +00:00
pub fn tree(metas: &[Meta], flags: &Flags, colors: &Colors, icons: &Icons) -> String {
let mut grid = Grid::new(GridOptions {
filling: Filling::Spaces(1),
direction: Direction::LeftToRight,
});
let padding_rules = get_padding_rules(metas, flags);
let mut index = 0;
for (i, block) in flags.blocks.0.iter().enumerate() {
if let Block::Name = block {
index = i;
break;
}
}
for cell in inner_display_tree(metas, flags, colors, icons, (0, ""), &padding_rules, index) {
grid.add(cell);
}
grid.fit_into_columns(flags.blocks.0.len()).to_string()
2019-01-20 10:22:14 +00:00
}
2019-10-24 15:18:42 +00:00
fn inner_display_grid(
2020-02-04 04:32:36 +00:00
display_option: &DisplayOption,
2019-10-23 15:26:39 +00:00
metas: &[Meta],
flags: &Flags,
2019-01-20 10:22:14 +00:00
colors: &Colors,
icons: &Icons,
depth: usize,
2019-10-24 15:18:42 +00:00
term_width: Option<usize>,
2019-01-20 10:22:14 +00:00
) -> String {
let mut output = String::new();
let padding_rules = get_padding_rules(metas, flags);
let mut grid = match flags.layout {
Layout::OneLine => Grid::new(GridOptions {
filling: Filling::Spaces(1),
direction: Direction::LeftToRight,
}),
_ => Grid::new(GridOptions {
filling: Filling::Spaces(2),
direction: Direction::TopToBottom,
}),
};
2018-12-02 16:22:51 +00:00
2019-05-24 13:30:36 +00:00
// The first iteration (depth == 0) corresponds to the inputs given by the
// user. We defer displaying directories given by the user unless we've been
// asked to display the directory itself (rather than its contents).
let skip_dirs = (depth == 0) && (flags.display != Display::DirectoryOnly);
2019-05-24 13:30:36 +00:00
2019-01-20 10:22:14 +00:00
// print the files first.
2020-02-04 04:49:04 +00:00
for meta in metas {
2019-05-24 13:30:36 +00:00
// Maybe skip showing the directory meta now; show its contents later.
if skip_dirs
&& (matches!(meta.file_type, FileType::Directory { .. })
2020-08-21 19:16:59 +00:00
|| (matches!(meta.file_type, FileType::SymLink { is_dir: true })
&& flags.layout != Layout::OneLine))
{
2019-05-24 13:30:36 +00:00
continue;
}
2020-02-04 04:32:36 +00:00
let blocks = get_output(
meta,
colors,
icons,
flags,
display_option,
2020-02-04 04:32:36 +00:00
&padding_rules,
(0, ""),
2020-02-04 04:32:36 +00:00
);
for block in blocks {
let block_str = block.to_string();
grid.add(Cell {
width: get_visible_width(&block_str),
contents: block_str,
});
}
2018-12-02 16:22:51 +00:00
}
2019-10-24 15:18:42 +00:00
if flags.layout == Layout::Grid {
if let Some(tw) = term_width {
if let Some(gridded_output) = grid.fit_into_width(tw) {
output += &gridded_output.to_string();
} else {
//does not fit into grid, usually because (some) filename(s)
//are longer or almost as long as term_width
//print line by line instead!
output += &grid.fit_into_columns(1).to_string();
2019-01-20 10:22:14 +00:00
}
} else {
output += &grid.fit_into_columns(1).to_string();
}
2019-01-20 10:22:14 +00:00
} else {
output += &grid.fit_into_columns(flags.blocks.0.len()).to_string();
2018-12-02 16:22:51 +00:00
}
let should_display_folder_path = should_display_folder_path(depth, metas, flags);
2019-01-12 15:17:40 +00:00
2019-01-20 10:22:14 +00:00
// print the folder content
for meta in metas {
if meta.content.is_some() {
if should_display_folder_path {
output += &display_folder_path(meta);
2019-01-12 15:17:40 +00:00
}
let display_option = DisplayOption::Relative {
base_path: &meta.path,
2020-02-04 04:32:36 +00:00
};
2019-01-20 10:22:14 +00:00
output += &inner_display_grid(
2020-02-04 04:32:36 +00:00
&display_option,
2019-10-24 15:18:42 +00:00
meta.content.as_ref().unwrap(),
flags,
2019-01-20 10:22:14 +00:00
colors,
icons,
depth + 1,
term_width,
);
2019-01-12 15:17:40 +00:00
}
}
2019-01-20 10:22:14 +00:00
output
}
fn inner_display_tree(
2019-10-23 15:26:39 +00:00
metas: &[Meta],
flags: &Flags,
2019-01-20 10:22:14 +00:00
colors: &Colors,
icons: &Icons,
tree_depth_prefix: (usize, &str),
padding_rules: &HashMap<Block, usize>,
tree_index: usize,
) -> Vec<Cell> {
let mut cells = Vec::new();
2019-01-20 10:22:14 +00:00
let last_idx = metas.len();
for (idx, meta) in metas.iter().enumerate() {
let current_prefix = if tree_depth_prefix.0 > 0 {
if idx + 1 != last_idx {
// is last folder elem
format!("{}{} ", tree_depth_prefix.1, EDGE)
} else {
format!("{}{} ", tree_depth_prefix.1, CORNER)
}
} else {
tree_depth_prefix.1.to_string()
};
2020-02-04 04:32:36 +00:00
for block in get_output(
meta,
colors,
icons,
flags,
2020-02-04 04:32:36 +00:00
&DisplayOption::FileName,
padding_rules,
(tree_index, &current_prefix),
2020-02-04 04:32:36 +00:00
) {
let block_str = block.to_string();
cells.push(Cell {
width: get_visible_width(&block_str),
contents: block_str,
});
}
2018-12-04 13:54:56 +00:00
2019-01-20 10:22:14 +00:00
if meta.content.is_some() {
let new_prefix = if tree_depth_prefix.0 > 0 {
if idx + 1 != last_idx {
// is last folder elem
format!("{}{} ", tree_depth_prefix.1, LINE)
2019-01-23 17:02:36 +00:00
} else {
format!("{}{} ", tree_depth_prefix.1, BLANK)
2019-01-23 17:02:36 +00:00
}
} else {
tree_depth_prefix.1.to_string()
};
2019-01-23 17:02:36 +00:00
cells.extend(inner_display_tree(
meta.content.as_ref().unwrap(),
flags,
2019-01-23 17:02:36 +00:00
colors,
icons,
(tree_depth_prefix.0 + 1, &new_prefix),
padding_rules,
tree_index,
));
2019-01-20 10:22:14 +00:00
}
2018-12-04 13:54:56 +00:00
}
cells
2019-01-20 10:22:14 +00:00
}
2020-08-21 19:16:59 +00:00
fn should_display_folder_path(depth: usize, metas: &[Meta], flags: &Flags) -> bool {
2019-01-20 10:22:14 +00:00
if depth > 0 {
true
} else {
let folder_number = metas
.iter()
.filter(|x| {
matches!(x.file_type, FileType::Directory { .. })
2020-08-21 19:16:59 +00:00
|| (matches!(x.file_type, FileType::SymLink { is_dir: true })
&& flags.layout != Layout::OneLine)
})
2019-01-20 10:22:14 +00:00
.count();
folder_number > 1 || folder_number < metas.len()
}
}
fn display_folder_path(meta: &Meta) -> String {
let mut output = String::new();
output.push('\n');
output += &meta.path.to_string_lossy();
output += ":\n";
output
}
fn get_output<'a>(
meta: &'a Meta,
colors: &'a Colors,
icons: &'a Icons,
flags: &'a Flags,
2020-02-02 17:41:43 +00:00
display_option: &DisplayOption,
padding_rules: &HashMap<Block, usize>,
tree: (usize, &'a str),
) -> Vec<String> {
let mut strings: Vec<String> = Vec::new();
for (i, block) in flags.blocks.0.iter().enumerate() {
let mut block_vec = if Layout::Tree == flags.layout && tree.0 == i {
vec![colors.colorize(tree.1.to_string(), &Elem::TreeEdge)]
} else {
Vec::new()
};
match block {
Block::INode => block_vec.push(meta.inode.render(colors)),
Block::Links => block_vec.push(meta.links.render(colors)),
Block::Permission => {
block_vec.extend(vec![
meta.file_type.render(colors),
meta.permissions.render(colors),
]);
}
Block::User => block_vec.push(meta.owner.render_user(colors)),
Block::Group => block_vec.push(meta.owner.render_group(colors)),
Block::Size => {
let pad = if Layout::Tree == flags.layout && 0 == tree.0 && 0 == i {
None
} else {
Some(padding_rules[&Block::SizeValue])
};
block_vec.push(meta.size.render(colors, flags, pad))
}
Block::SizeValue => block_vec.push(meta.size.render_value(colors, flags)),
Block::Date => block_vec.push(meta.date.render(colors, flags)),
2019-05-18 13:49:29 +00:00
Block::Name => {
block_vec.extend(vec![
meta.name.render(colors, icons, display_option),
meta.indicator.render(flags),
]);
if !(flags.no_symlink.0 || flags.dereference.0 || flags.layout == Layout::Grid) {
block_vec.push(meta.symlink.render(colors, flags))
}
2019-05-18 13:49:29 +00:00
}
};
strings.push(
block_vec
.into_iter()
.map(|s| s.to_string())
.collect::<Vec<String>>()
.join(""),
);
}
strings
2019-01-20 10:22:14 +00:00
}
fn get_visible_width(input: &str) -> usize {
let mut nb_invisible_char = 0;
// If the input has color, do not compute the length contributed by the color to the actual length
for (idx, _) in input.match_indices("\u{1b}[") {
let (_, s) = input.split_at(idx);
let m_pos = s.find('m');
if let Some(len) = m_pos {
2019-10-30 09:17:02 +00:00
nb_invisible_char += len
}
2019-01-20 10:22:14 +00:00
}
UnicodeWidthStr::width(input) - nb_invisible_char
}
fn detect_size_lengths(metas: &[Meta], flags: &Flags) -> usize {
2019-01-20 10:22:14 +00:00
let mut max_value_length: usize = 0;
2018-12-02 16:22:51 +00:00
2019-01-20 10:22:14 +00:00
for meta in metas {
2019-10-23 15:34:57 +00:00
let value_len = meta.size.value_string(flags).len();
if value_len > max_value_length {
max_value_length = value_len;
}
if Layout::Tree == flags.layout {
if let Some(subs) = &meta.content {
let sub_length = detect_size_lengths(subs, flags);
if sub_length > max_value_length {
max_value_length = sub_length;
}
}
}
2018-12-02 16:22:51 +00:00
}
2019-01-20 10:22:14 +00:00
max_value_length
2018-12-02 16:22:51 +00:00
}
2019-05-04 10:56:27 +00:00
2019-10-24 13:42:26 +00:00
fn get_padding_rules(metas: &[Meta], flags: &Flags) -> HashMap<Block, usize> {
let mut padding_rules: HashMap<Block, usize> = HashMap::new();
if flags.blocks.0.contains(&Block::Size) {
let size_val = detect_size_lengths(metas, flags);
2019-10-24 13:42:26 +00:00
padding_rules.insert(Block::SizeValue, size_val);
}
padding_rules
}
#[cfg(test)]
mod tests {
use super::*;
2019-02-09 10:41:42 +00:00
use crate::color;
use crate::color::Colors;
use crate::icon::Icons;
use crate::meta::{FileType, Name};
use crate::Config;
use crate::{app, flags, icon, sort};
use assert_fs::prelude::*;
2018-12-20 02:51:44 +00:00
use std::path::Path;
#[test]
fn test_display_get_visible_width_without_icons() {
for (s, l) in &[
(",!", 22),
("ASCII1234-_", 11),
("制作样本。", 10),
("日本語", 6),
("샘플은 무료로 드리겠습니다", 26),
("👩🐩", 4),
("🔬", 2),
] {
let path = Path::new(s);
let name = Name::new(
&path,
FileType::File {
exec: false,
uid: false,
},
);
let output = name
.render(
&Colors::new(color::ThemeOption::NoColor),
&Icons::new(icon::Theme::NoIcon, " ".to_string()),
&DisplayOption::FileName,
)
.to_string();
2019-01-20 10:22:14 +00:00
assert_eq!(get_visible_width(&output), *l);
}
}
#[test]
fn test_display_get_visible_width_with_icons() {
for (s, l) in &[
// Add 3 characters for the icons.
2019-11-04 16:10:09 +00:00
(",!", 24),
("ASCII1234-_", 13),
("File with space", 17),
("制作样本。", 12),
("日本語", 8),
("샘플은 무료로 드리겠습니다", 28),
("👩🐩", 6),
("🔬", 4),
] {
let path = Path::new(s);
let name = Name::new(
&path,
FileType::File {
exec: false,
uid: false,
},
);
let output = name
.render(
&Colors::new(color::ThemeOption::NoColor),
&Icons::new(icon::Theme::Fancy, " ".to_string()),
2020-02-04 04:32:36 +00:00
&DisplayOption::FileName,
)
.to_string();
2019-01-20 10:22:14 +00:00
assert_eq!(get_visible_width(&output), *l);
}
}
#[test]
fn test_display_get_visible_width_with_colors() {
for (s, l) in &[
2019-03-11 15:12:16 +00:00
(",!", 22),
("ASCII1234-_", 11),
2019-03-11 15:12:16 +00:00
("File with space", 15),
("制作样本。", 10),
("日本語", 6),
("샘플은 무료로 드리겠습니다", 26),
("👩🐩", 4),
("🔬", 2),
] {
let path = Path::new(s);
let name = Name::new(
&path,
FileType::File {
exec: false,
uid: false,
},
);
let output = name
.render(
&Colors::new(color::ThemeOption::NoLscolors),
&Icons::new(icon::Theme::NoIcon, " ".to_string()),
2020-02-04 04:32:36 +00:00
&DisplayOption::FileName,
)
.to_string();
// check if the color is present.
assert_eq!(
true,
output.starts_with("\u{1b}[38;5;"),
"{:?} should start with color",
output,
);
assert_eq!(true, output.ends_with("[39m"), "reset foreground color");
assert_eq!(get_visible_width(&output), *l, "visible match");
2019-03-11 15:12:16 +00:00
}
}
#[test]
fn test_display_get_visible_width_without_colors() {
for (s, l) in &[
(",!", 22),
("ASCII1234-_", 11),
("File with space", 15),
("制作样本。", 10),
("日本語", 6),
("샘플은 무료로 드리겠습니다", 26),
("👩🐩", 4),
("🔬", 2),
] {
let path = Path::new(s);
let name = Name::new(
&path,
FileType::File {
exec: false,
uid: false,
},
);
let output = name
.render(
&Colors::new(color::ThemeOption::NoColor),
&Icons::new(icon::Theme::NoIcon, " ".to_string()),
2020-02-04 04:32:36 +00:00
&DisplayOption::FileName,
2019-03-11 15:12:16 +00:00
)
.to_string();
// check if the color is present.
assert_eq!(false, output.starts_with("\u{1b}[38;5;"));
assert_eq!(false, output.ends_with("[0m"));
2019-01-20 10:22:14 +00:00
assert_eq!(get_visible_width(&output), *l);
}
}
fn sort(metas: &mut Vec<Meta>, sorters: &Vec<(flags::SortOrder, sort::SortFn)>) {
metas.sort_unstable_by(|a, b| sort::by_meta(sorters, a, b));
for meta in metas {
if let Some(ref mut content) = meta.content {
sort(content, sorters);
}
}
}
#[test]
fn test_display_tree_with_all() {
let argv = vec!["lsd", "--tree", "--all"];
let matches = app::build().get_matches_from_safe(argv).unwrap();
let flags = Flags::configure_from(&matches, &Config::with_none()).unwrap();
let dir = assert_fs::TempDir::new().unwrap();
dir.child("one.d").create_dir_all().unwrap();
dir.child("one.d/two").touch().unwrap();
dir.child("one.d/.hidden").touch().unwrap();
let mut metas = Meta::from_path(Path::new(dir.path()), false)
.unwrap()
.recurse_into(42, &flags)
.unwrap()
.unwrap();
sort(&mut metas, &sort::assemble_sorters(&flags));
let output = tree(
&metas,
&flags,
&Colors::new(color::ThemeOption::NoColor),
&Icons::new(icon::Theme::NoIcon, " ".to_string()),
);
assert_eq!("one.d\n├── .hidden\n└── two\n", output);
}
/// Different level of folder may form a different width
/// we must make sure it is aligned in all level
///
/// dir has a bytes size
/// empty file has an empty size
/// `---blocks size,name` can help us for this case
#[test]
fn test_tree_align_subfolder() {
let argv = vec!["lsd", "--tree", "--blocks", "size,name"];
let matches = app::build().get_matches_from_safe(argv).unwrap();
let flags = Flags::configure_from(&matches, &Config::with_none()).unwrap();
let dir = assert_fs::TempDir::new().unwrap();
dir.child("dir").create_dir_all().unwrap();
dir.child("dir/file").touch().unwrap();
let metas = Meta::from_path(Path::new(dir.path()), false)
.unwrap()
.recurse_into(42, &flags)
.unwrap()
.unwrap();
let output = tree(
&metas,
&flags,
&Colors::new(color::ThemeOption::NoColor),
&Icons::new(icon::Theme::NoIcon, " ".to_string()),
);
let length_before_b = |i| -> usize {
output
.lines()
.nth(i)
.unwrap()
.split(|c| c == 'K' || c == 'B')
.nth(0)
.unwrap()
.len()
};
assert_eq!(length_before_b(0), length_before_b(1));
assert_eq!(
output.lines().nth(0).unwrap().find("d"),
output.lines().nth(1).unwrap().find("")
);
}
#[test]
#[cfg(unix)]
fn test_tree_size_first_without_name() {
let argv = vec!["lsd", "--tree", "--blocks", "size,permission"];
let matches = app::build().get_matches_from_safe(argv).unwrap();
let flags = Flags::configure_from(&matches, &Config::with_none()).unwrap();
let dir = assert_fs::TempDir::new().unwrap();
dir.child("dir").create_dir_all().unwrap();
dir.child("dir/file").touch().unwrap();
let metas = Meta::from_path(Path::new(dir.path()), false)
.unwrap()
.recurse_into(42, &flags)
.unwrap()
.unwrap();
let output = tree(
&metas,
&flags,
&Colors::new(color::ThemeOption::NoColor),
&Icons::new(icon::Theme::NoIcon, " ".to_string()),
);
assert_eq!(output.lines().nth(1).unwrap().chars().nth(0).unwrap(), '└');
assert_eq!(
output
.lines()
.nth(0)
.unwrap()
.chars()
.position(|x| x == 'd'),
output
.lines()
.nth(1)
.unwrap()
.chars()
.position(|x| x == '.'),
);
}
#[test]
fn test_tree_edge_before_name() {
let argv = vec!["lsd", "--tree", "--long"];
let matches = app::build().get_matches_from_safe(argv).unwrap();
let flags = Flags::configure_from(&matches, &Config::with_none()).unwrap();
let dir = assert_fs::TempDir::new().unwrap();
dir.child("one.d").create_dir_all().unwrap();
dir.child("one.d/two").touch().unwrap();
let metas = Meta::from_path(Path::new(dir.path()), false)
.unwrap()
.recurse_into(42, &flags)
.unwrap()
.unwrap();
let output = tree(
&metas,
&flags,
&Colors::new(color::ThemeOption::NoColor),
&Icons::new(icon::Theme::NoIcon, " ".to_string()),
);
assert!(output.ends_with("└── two\n"));
}
}