223 lines
6.3 KiB
Rust
223 lines
6.3 KiB
Rust
use clap::{Parser, ArgAction};
|
|
use glob::Pattern;
|
|
|
|
use crate::unit::Unit;
|
|
|
|
use std::fs::{symlink_metadata, Metadata};
|
|
use std::path::{Component, Path};
|
|
use std::slice::Iter;
|
|
use std::iter::once_with;
|
|
|
|
#[allow(clippy::struct_excessive_bools)]
|
|
#[derive(Parser, Debug, Clone)]
|
|
pub struct Args {
|
|
#[arg(
|
|
short, long, default_value_t = false,
|
|
help = "keep going if an error occurs",
|
|
long_help = "keep going if an error occurs (ex. unreadable subdirectories in a readable directory)"
|
|
)]
|
|
persistant: bool,
|
|
|
|
#[arg(
|
|
short, long,
|
|
help = "minimize output",
|
|
long_help = "print nothing but the total size for all directories, without a newline. Also supresses all error messages",
|
|
conflicts_with = "total",
|
|
default_value_t = false,
|
|
)]
|
|
minimal: bool,
|
|
|
|
#[arg(
|
|
short='T', long,
|
|
help = "display in tree",
|
|
default_value_t = false,
|
|
conflicts_with = "minimal",
|
|
)]
|
|
tree: bool,
|
|
|
|
#[arg(
|
|
short, long,
|
|
help = "display the total size",
|
|
conflicts_with = "minimal",
|
|
default_value_t = false,
|
|
)]
|
|
total: bool,
|
|
|
|
#[arg(
|
|
short='2', long,
|
|
help = "alias for --unit 1024",
|
|
default_value_t = false,
|
|
conflicts_with_all = ["si","unit"],
|
|
)]
|
|
base_two: bool,
|
|
|
|
#[arg(
|
|
short='k', long,
|
|
help = "alias for --unit 1000",
|
|
default_value_t = false,
|
|
conflicts_with_all = ["base_two","unit"],
|
|
)]
|
|
si: bool,
|
|
|
|
#[arg(
|
|
short, long,
|
|
help = "unit to print in",
|
|
long_help = "printing unit (case insensitive): b = bytes, kb = kilobytes, ki = kibibytes, gb = gigabytes, gi = gibibytes, tb = terabytes, ti = tibibytes",
|
|
value_parser = Unit::parse,
|
|
default_value_t = Unit::Byte,
|
|
conflicts_with_all = ["base_two","si"],
|
|
)]
|
|
unit: Unit,
|
|
|
|
#[arg(
|
|
short='s', long,
|
|
help = "follow symlinks",
|
|
default_value_t = false,
|
|
)]
|
|
follow_links: bool,
|
|
|
|
#[arg(
|
|
short='x', long = "exclude",
|
|
help = "include in search, but exclude from printing",
|
|
long_help = "include in search, but exclude from printing. accepts glob syntax",
|
|
default_values_t = once_with(|| Pattern::new(".*").unwrap()),
|
|
value_parser = parse_glob,
|
|
value_delimiter = ',',
|
|
action = ArgAction::Append,
|
|
)]
|
|
exclude_print: Vec<Pattern>,
|
|
|
|
#[arg(
|
|
short='X', long,
|
|
help = "exclude from search and printing",
|
|
value_parser = parse_glob,
|
|
value_delimiter = ',',
|
|
action = ArgAction::Append,
|
|
)]
|
|
exclude_search: Vec<Pattern>,
|
|
|
|
#[arg(
|
|
short='H', long,
|
|
help = "disable implicit hiding of results",
|
|
long_help = "don't implicitly hide dotfiles and dot directories",
|
|
conflicts_with = "exclude_print",
|
|
default_value_t = false,
|
|
)]
|
|
show_hidden: bool,
|
|
|
|
#[arg(
|
|
value_parser = validate_path,
|
|
help = "items to summate",
|
|
action = ArgAction::Append,
|
|
num_args = 1..
|
|
)]
|
|
path: Vec<String>,
|
|
}
|
|
impl Args {
|
|
/// utility method to chuck default values on the end
|
|
/// it feels like I should be able to do this with
|
|
/// clever `clap` macros but I don't know how
|
|
pub fn post_process(mut self) -> Self {
|
|
if self.base_two {
|
|
self.unit = Unit::Kibi;
|
|
} else if self.si {
|
|
self.unit = Unit::Kilo;
|
|
}
|
|
|
|
if self.show_hidden {
|
|
self.exclude_print = Vec::new();
|
|
}
|
|
|
|
if self.path.is_empty() {
|
|
self.path = vec![ ".".to_owned() ];
|
|
}
|
|
|
|
self
|
|
}
|
|
|
|
pub fn should_exclude(&self, path: &Path, file: &Metadata) -> bool {
|
|
if !self.follow_links
|
|
&& file.is_symlink()
|
|
// `.` counts as a symlink. excluding . is usually not
|
|
// useful, so even if this is a symlink when we're not
|
|
// supposed to be following them, if this opens with a
|
|
// CurDir component then we shouldn't exclude
|
|
&& !matches!(path.components().nth(0), Some(Component::CurDir))
|
|
{
|
|
return true
|
|
}
|
|
|
|
any_pattern_matches_any_component(&self.exclude_search, path)
|
|
}
|
|
|
|
pub fn should_print(&self, path: &Path) -> bool {
|
|
! any_pattern_matches_any_component(&self.exclude_print, path)
|
|
// TODO: this exists because when a file matches an exclude pattern
|
|
// is it still returned, just with no size or children, so in order
|
|
// to not accidentally print things that we said we were excluding,
|
|
// we also have to check that it's not excluded by search.
|
|
// `self.exclude_print.extend(&self.exclude_search)` is wasteful,
|
|
// but until I find a better way this is what it's gotta be`
|
|
&& ! any_pattern_matches_any_component(&self.exclude_search, path)
|
|
}
|
|
|
|
pub const fn persistant(&self) -> bool {
|
|
self.persistant
|
|
}
|
|
|
|
pub const fn minimal(&self) -> bool {
|
|
self.minimal
|
|
}
|
|
|
|
pub const fn tree(&self) -> bool {
|
|
self.tree
|
|
}
|
|
|
|
pub const fn total(&self) -> bool {
|
|
self.total
|
|
}
|
|
|
|
pub const fn unit(&self) -> Unit {
|
|
self.unit
|
|
}
|
|
|
|
pub fn iter(&self) -> Iter<'_, String> {
|
|
self.path.iter()
|
|
}
|
|
}
|
|
|
|
fn validate_path(s: &str) -> Result<String, String> {
|
|
// try to access it's metadata, since that is what is used
|
|
// to get its length. using symlink because that's what's
|
|
// used in the actual program
|
|
symlink_metadata(s)
|
|
.map(|_| s.to_string())
|
|
.map_err(|e| e.to_string())
|
|
}
|
|
|
|
fn parse_glob(s: &str) -> Result<Pattern, String> {
|
|
Pattern::new(s).map_err(|globerr| format!("invalid glob \"{s}\": {}", globerr.msg))
|
|
}
|
|
|
|
fn any_pattern_matches_any_component(patterns: &[Pattern], path: &Path) -> bool {
|
|
for pat in patterns {
|
|
for cmp in path.components() {
|
|
let Component::Normal(cmp) = cmp else {
|
|
// this seems wacky, but only normal components
|
|
// are useful
|
|
continue
|
|
};
|
|
let Some(s) = cmp.to_str() else {
|
|
// this is a code smell
|
|
// I don't believe it, but I can't think
|
|
// of anything worthwhile to do
|
|
continue
|
|
};
|
|
if pat.matches(s) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
false
|
|
} |