use crate::color::Colors;
use crate::display;
use crate::flags::{
ColorOption, Display, Flags, HyperlinkOption, IconOption, IconTheme, Layout, SortOrder,
ThemeOption,
};
use crate::icon::{self, Icons};
use crate::meta::Meta;
use crate::{print_error, print_output, sort, ExitCode};
use std::path::PathBuf;
#[cfg(not(target_os = "windows"))]
use std::io;
#[cfg(not(target_os = "windows"))]
use std::os::unix::io::AsRawFd;
#[cfg(target_os = "windows")]
use terminal_size::terminal_size;
pub struct Core {
flags: Flags,
icons: Icons,
colors: Colors,
sorters: Vec<(SortOrder, sort::SortFn)>,
}
impl Core {
pub fn new(mut flags: Flags) -> Self {
#[cfg(not(target_os = "windows"))]
let tty_available = unsafe { libc::isatty(io::stdout().as_raw_fd()) == 1 };
#[cfg(not(target_os = "windows"))]
let console_color_ok = true;
#[cfg(target_os = "windows")]
let tty_available = terminal_size().is_some();
#[cfg(target_os = "windows")]
let console_color_ok = crossterm::ansi_support::supports_ansi();
let mut inner_flags = flags.clone();
let color_theme = match (tty_available && console_color_ok, flags.color.when) {
(_, ColorOption::Never) | (false, ColorOption::Auto) => ThemeOption::NoColor,
_ => flags.color.theme.clone(),
};
let icon_theme = match (tty_available, flags.icons.when, flags.icons.theme) {
(_, IconOption::Never, _) | (false, IconOption::Auto, _) => icon::Theme::NoIcon,
(_, _, IconTheme::Fancy) => icon::Theme::Fancy,
(_, _, IconTheme::Unicode) => icon::Theme::Unicode,
};
if matches!(flags.hyperlink, HyperlinkOption::Auto) {
flags.hyperlink = if tty_available {
HyperlinkOption::Always
} else {
HyperlinkOption::Never
}
}
let icon_separator = flags.icons.separator.0.clone();
if !tty_available {
inner_flags.layout = Layout::OneLine;
};
let sorters = sort::assemble_sorters(&flags);
Self {
flags,
colors: Colors::new(color_theme),
icons: Icons::new(icon_theme, icon_separator),
sorters,
}
}
pub fn run(self, paths: Vec<PathBuf>) -> ExitCode {
let (mut meta_list, exit_code) = self.fetch(paths);
self.sort(&mut meta_list);
self.display(&meta_list);
exit_code
}
fn fetch(&self, paths: Vec<PathBuf>) -> (Vec<Meta>, ExitCode) {
let mut exit_code = ExitCode::OK;
let mut meta_list = Vec::with_capacity(paths.len());
let depth = match self.flags.layout {
Layout::Tree { .. } => self.flags.recursion.depth,
_ if self.flags.recursion.enabled => self.flags.recursion.depth,
_ => 1,
};
for path in paths {
let mut meta = match Meta::from_path(&path, self.flags.dereference.0) {
Ok(meta) => meta,
Err(err) => {
print_error!("{}: {}.", path.display(), err);
exit_code.set_if_greater(ExitCode::MajorIssue);
continue;
}
};
let recurse =
self.flags.layout == Layout::Tree || self.flags.display != Display::DirectoryOnly;
if recurse {
match meta.recurse_into(depth, &self.flags) {
Ok((content, path_exit_code)) => {
meta.content = content;
meta_list.push(meta);
exit_code.set_if_greater(path_exit_code);
}
Err(err) => {
print_error!("lsd: {}: {}\n", path.display(), err);
exit_code.set_if_greater(ExitCode::MinorIssue);
continue;
}
};
} else {
meta_list.push(meta);
};
}
if self.flags.total_size.0 && self.flags.blocks.displays_size() {
for meta in &mut meta_list.iter_mut() {
meta.calculate_total_size();
}
}
(meta_list, exit_code)
}
fn sort(&self, metas: &mut Vec<Meta>) {
metas.sort_unstable_by(|a, b| sort::by_meta(&self.sorters, a, b));
for meta in metas {
if let Some(ref mut content) = meta.content {
self.sort(content);
}
}
}
fn display(&self, metas: &[Meta]) {
let output = if self.flags.layout == Layout::Tree {
display::tree(metas, &self.flags, &self.colors, &self.icons)
} else {
display::grid(metas, &self.flags, &self.colors, &self.icons)
};
print_output!("{}", output);
}
}