2000 lines
67 KiB
Rust
2000 lines
67 KiB
Rust
//! `squid` — one tool for cleaning, uninstalling, purging and watching a Mac.
|
|
//!
|
|
//! The binary is deliberately thin: every decision about *what* may be deleted
|
|
//! is made in `squid-engine`, and every deletion goes through
|
|
//! `squid_engine::delete`, which re-checks each path against the safety policy
|
|
//! and the ledger. This file only parses arguments, shows progress and asks for
|
|
//! confirmation.
|
|
|
|
use anyhow::{Context, Result};
|
|
use clap::{Args, Parser, Subcommand};
|
|
use crossterm::tty::IsTty;
|
|
use squid_core::progress::{CancelToken, Event, Progress};
|
|
use squid_core::{
|
|
paths, Bytes, Category, CleanSummary, CleanupItem, DeleteMode, Locale, ScanReport, Settings,
|
|
};
|
|
use squid_engine::analyze;
|
|
use squid_engine::delete::{self, DeleteJob};
|
|
use squid_engine::{clean, purge, uninstall, Engine};
|
|
use squid_platform::currency::Exchange;
|
|
use squid_platform::TrashTarget;
|
|
use std::io::Write;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::{Arc, OnceLock};
|
|
use std::time::Duration;
|
|
|
|
// ------------------------------------------------------------------------ CLI
|
|
|
|
#[derive(Parser, Debug)]
|
|
#[command(
|
|
name = "squid",
|
|
version,
|
|
about = "clean · uninstall · purge · watch — a system utility that never touches what it does not own",
|
|
long_about = None,
|
|
disable_help_subcommand = true
|
|
)]
|
|
struct Cli {
|
|
#[command(subcommand)]
|
|
command: Option<Command>,
|
|
|
|
/// Machine-readable output where supported
|
|
#[arg(long, global = true)]
|
|
json: bool,
|
|
|
|
/// Only the essential lines
|
|
#[arg(long, short = 'q', global = true)]
|
|
quiet: bool,
|
|
|
|
/// Never emit ANSI colour
|
|
#[arg(long, global = true)]
|
|
no_color: bool,
|
|
|
|
/// Interface language: `zh` or `en`. Overrides the locale the terminal
|
|
/// exported, which Terminal.app does not export at all.
|
|
#[arg(long, global = true, value_name = "LANG")]
|
|
lang: Option<String>,
|
|
}
|
|
|
|
#[derive(Subcommand, Debug)]
|
|
enum Command {
|
|
/// Clear caches, logs, browser junk, DerivedData and other regenerable files
|
|
Clean(CleanArgs),
|
|
/// Remove an application together with everything it left behind
|
|
Uninstall(UninstallArgs),
|
|
/// Deep clean: node_modules, build folders, disk images, stale archives
|
|
Purge(PurgeArgs),
|
|
/// Open the interface: disk map, system meters, cleanup, history
|
|
State,
|
|
/// One-shot system snapshot (scripts, dotfiles, cron)
|
|
Status(StatusArgs),
|
|
/// Who owns this disk? A size tree for one path
|
|
Analyze(AnalyzeArgs),
|
|
/// What squid has already removed
|
|
History(HistoryArgs),
|
|
#[command(about = format!("Put a session's files back from the {}", bin()))]
|
|
Undo(UndoArgs),
|
|
/// Protect a path from every future scan
|
|
Whitelist(WhitelistArgs),
|
|
/// List the cleanup rules squid knows
|
|
Rules,
|
|
/// Report permissions, settings and ledger health
|
|
Doctor,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct CleanArgs {
|
|
/// Show what would go without deleting anything
|
|
#[arg(long)]
|
|
dry_run: bool,
|
|
/// Do not ask
|
|
#[arg(long, short = 'y')]
|
|
yes: bool,
|
|
/// Only these categories (caches, browsers, logs, developer, …)
|
|
#[arg(long, value_delimiter = ',')]
|
|
categories: Vec<String>,
|
|
/// Also look for leftovers of apps that are gone
|
|
#[arg(long)]
|
|
orphans: bool,
|
|
/// Override the per-rule age filter, in days (0 disables it)
|
|
#[arg(long)]
|
|
min_age: Option<u64>,
|
|
/// Skip rules that need administrator rights
|
|
#[arg(long)]
|
|
user_only: bool,
|
|
#[arg(long, conflicts_with = "permanent", help = format!("Move to {} (default)", bin()))]
|
|
trash: bool,
|
|
#[arg(long, conflicts_with = "trash", help = format!("Delete for real, skipping the {}", bin()))]
|
|
permanent: bool,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct UninstallArgs {
|
|
/// Application name or bundle identifier
|
|
name: Option<String>,
|
|
/// List installed applications
|
|
#[arg(long)]
|
|
list: bool,
|
|
#[arg(long)]
|
|
dry_run: bool,
|
|
#[arg(long, short = 'y')]
|
|
yes: bool,
|
|
#[arg(long, conflicts_with = "permanent", help = format!("Move to {} (default)", bin()))]
|
|
trash: bool,
|
|
#[arg(long, conflicts_with = "trash", help = format!("Delete for real, skipping the {}", bin()))]
|
|
permanent: bool,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct PurgeArgs {
|
|
/// Where to look; defaults to the configured purge roots
|
|
paths: Vec<String>,
|
|
#[arg(long)]
|
|
dry_run: bool,
|
|
#[arg(long, short = 'y')]
|
|
yes: bool,
|
|
/// Also offer folders that might still be needed
|
|
#[arg(long)]
|
|
all: bool,
|
|
/// Age filter in days (default from settings)
|
|
#[arg(long)]
|
|
min_age: Option<u64>,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct StatusArgs {
|
|
/// How many processes to list
|
|
#[arg(long, default_value_t = 8)]
|
|
processes: usize,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct AnalyzeArgs {
|
|
/// Path to measure (default: your home folder)
|
|
path: Option<String>,
|
|
/// Levels below the root
|
|
#[arg(long, default_value_t = 1)]
|
|
depth: usize,
|
|
/// Children to show per folder
|
|
#[arg(long, default_value_t = 24)]
|
|
top: usize,
|
|
/// Also list the largest files
|
|
#[arg(long)]
|
|
files: bool,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct HistoryArgs {
|
|
#[arg(long, default_value_t = 20)]
|
|
limit: usize,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct UndoArgs {
|
|
#[arg(help = format!("Session id; the newest session with files in the {} when omitted", bin()))]
|
|
session: Option<String>,
|
|
}
|
|
|
|
#[derive(Args, Debug)]
|
|
struct WhitelistArgs {
|
|
#[command(subcommand)]
|
|
action: WhitelistAction,
|
|
}
|
|
|
|
#[derive(Subcommand, Debug)]
|
|
enum WhitelistAction {
|
|
/// Never offer these paths again
|
|
Add { paths: Vec<String> },
|
|
/// Stop protecting these paths
|
|
Remove { paths: Vec<String> },
|
|
/// Show the list
|
|
List,
|
|
}
|
|
|
|
static COLOR: AtomicBool = AtomicBool::new(false);
|
|
static QUIET: AtomicBool = AtomicBool::new(false);
|
|
/// With `--json` stdout is a data stream: every human line is rerouted to
|
|
/// stderr so `squid clean --json | jq` never sees a progress message.
|
|
static DIAG_STDERR: AtomicBool = AtomicBool::new(false);
|
|
|
|
/// What to print when this console cannot afford the characters a report is
|
|
/// drawn out of.
|
|
///
|
|
/// The interface walks a finished frame; a command line has no frame, so its
|
|
/// frame is one line, and this is where a line stops being text and starts
|
|
/// being cells. It is the same exchange the interface spends, reached from the
|
|
/// other side — a gauge here repeats `█` twenty-eight times, and on the console
|
|
/// that turns the interface into a pile of half-frames it prints a Storage
|
|
/// table whose rows are each a screen and a half long.
|
|
///
|
|
/// The price is not measured here, even though measuring is what the interface
|
|
/// does. Measuring spends characters on whatever the console is showing at the
|
|
/// time, and a command line is a guest on that screen: it is in a pipeline, or
|
|
/// somebody's shell is still sitting there waiting for its next prompt, and a
|
|
/// row of sixty test characters written and erased in front of them is somebody
|
|
/// else's work interrupted. So the command line takes the pessimistic price the
|
|
/// code page implies and buys nothing, which costs it a plainer gauge on a
|
|
/// console that a measurement might have cleared. A table that fits is worth
|
|
/// more than a prettier one that does not.
|
|
///
|
|
/// See [`squid_platform::console::prices_unasked`] for that reasoning at the
|
|
/// counter, and `squid_tui::glyphs` for the half that walks a frame.
|
|
fn change() -> &'static Exchange {
|
|
static CHANGE: OnceLock<Exchange> = OnceLock::new();
|
|
CHANGE.get_or_init(|| Exchange::new(squid_platform::console::prices_unasked()))
|
|
}
|
|
|
|
/// One line a person is shown, in the characters their console can pay for.
|
|
///
|
|
/// Nobody is stopped from seeing what a report actually says. Point the output
|
|
/// at a file or a pipe and the text comes back as it was, because a file is not
|
|
/// a console: whatever glass reads it tomorrow may well be able to afford the
|
|
/// `█`, and an archive of `#` is a worse record for the sake of a screen that
|
|
/// was never looking. Only a screen is offered the exchange.
|
|
fn priced(text: &str) -> String {
|
|
if !human_stream_is_tty() {
|
|
return text.to_string();
|
|
}
|
|
change().afford(text)
|
|
}
|
|
|
|
/// Print one row of a report.
|
|
///
|
|
/// [`diag`] and [`say`] own the lines that carry a colour code, obey `--quiet`
|
|
/// or dodge `--json`; what is left is the body of the tables, which is printed
|
|
/// straight out because a report's rows belong to the report whoever asked for
|
|
/// it. That leftover is also where every gauge, bullet and rule in this
|
|
/// program's output is drawn, which is why there is one macro for it rather
|
|
/// than thirteen `println!`s of which twelve remember the console and one does
|
|
/// not. `no_line_of_chrome_escapes_the_counter` is what keeps it that way.
|
|
macro_rules! row {
|
|
($($arg:tt)*) => {
|
|
println!("{}", $crate::priced(&format!($($arg)*)))
|
|
};
|
|
}
|
|
|
|
/// One human-readable diagnostic line.
|
|
fn diag(code: &str, text: &str) {
|
|
if DIAG_STDERR.load(Ordering::Relaxed) {
|
|
eprintln!("{}", priced(&paint(code, text)));
|
|
} else {
|
|
println!("{}", priced(&paint(code, text)));
|
|
}
|
|
}
|
|
|
|
/// One already-formatted human line. The plans and tables are built from
|
|
/// several `paint` fragments, so they cannot go through `diag`, but they obey
|
|
/// the same contract: `--quiet` hides them and `--json` reroutes them. A plan
|
|
/// table that leaks onto stdout is enough to break `squid purge --json --yes
|
|
/// | jq`, and the real machine is what caught it.
|
|
fn say(text: &str) {
|
|
if QUIET.load(Ordering::Relaxed) {
|
|
return;
|
|
}
|
|
if DIAG_STDERR.load(Ordering::Relaxed) {
|
|
if !text.is_empty() {
|
|
eprintln!("{}", priced(text));
|
|
}
|
|
} else {
|
|
println!("{}", priced(text));
|
|
}
|
|
}
|
|
|
|
/// The stream a human line lands on: stdout while it is still free, stderr
|
|
/// once `--json` has claimed it for JSON alone.
|
|
///
|
|
/// Two questions get asked of it, and they have the same answer. A progress
|
|
/// line may only overwrite a line when something can watch it being
|
|
/// overwritten. Chrome may only be exchanged for ASCII when somebody is looking
|
|
/// at the console that cannot afford it — because that is the only place the
|
|
/// exchange is an improvement rather than a loss.
|
|
fn human_stream_is_tty() -> bool {
|
|
if DIAG_STDERR.load(Ordering::Relaxed) {
|
|
std::io::stderr().is_tty()
|
|
} else {
|
|
std::io::stdout().is_tty()
|
|
}
|
|
}
|
|
|
|
/// Rewrite the live progress line, or clear it when `text` is `None`.
|
|
fn live(text: Option<&str>) {
|
|
let line = match text {
|
|
Some(text) => format!("\r\x1b[K{}", priced(text)),
|
|
None => "\r\x1b[K".to_string(),
|
|
};
|
|
if DIAG_STDERR.load(Ordering::Relaxed) {
|
|
write_live(&mut std::io::stderr().lock(), &line);
|
|
} else {
|
|
write_live(&mut std::io::stdout().lock(), &line);
|
|
}
|
|
}
|
|
|
|
fn write_live(sink: &mut dyn Write, line: &str) {
|
|
let _ = sink.write_all(line.as_bytes());
|
|
let _ = sink.flush();
|
|
}
|
|
|
|
fn main() {
|
|
let code = match run() {
|
|
Ok(code) => code,
|
|
Err(error) => {
|
|
if let Some(inner) = error.downcast_ref::<squid_core::SquidError>() {
|
|
if matches!(inner, squid_core::SquidError::Cancelled) {
|
|
eprintln!(
|
|
"{}",
|
|
priced(&paint("90", "cancelled — nothing was changed"))
|
|
);
|
|
std::process::exit(130);
|
|
}
|
|
}
|
|
eprintln!(
|
|
"{}",
|
|
priced(&format!("{} {}", paint("31", "squid:"), error))
|
|
);
|
|
let mut source = error.source();
|
|
while let Some(cause) = source.take() {
|
|
eprintln!("{}", priced(&paint("90", &format!(" caused by: {cause}"))));
|
|
source = cause.source();
|
|
}
|
|
std::process::exit(1);
|
|
}
|
|
};
|
|
std::process::exit(code);
|
|
}
|
|
|
|
fn run() -> Result<i32> {
|
|
let cli = Cli::parse();
|
|
COLOR.store(
|
|
!cli.no_color && std::io::stdout().is_tty(),
|
|
Ordering::Relaxed,
|
|
);
|
|
QUIET.store(cli.quiet, Ordering::Relaxed);
|
|
DIAG_STDERR.store(cli.json, Ordering::Relaxed);
|
|
// `--lang` is a flag on the whole program, so honour it for the whole
|
|
// program: publish it as the one hint every reader already agrees on
|
|
// before any command asks what language it should speak. Setting it only
|
|
// inside the interface branch made `squid --lang en doctor` answer with
|
|
// the language the *terminal* asked for, which reads like a bug.
|
|
if let Some(lang) = &cli.lang {
|
|
std::env::set_var("SQUID_LANG", lang);
|
|
}
|
|
|
|
match cli.command {
|
|
None | Some(Command::State) => {
|
|
if cli.no_color {
|
|
// The interface probes for colour when it opens, and
|
|
// https://no-color.org is the one promise every program agrees
|
|
// on — so `--no-color` is kept by saying it out loud rather
|
|
// than by teaching the TUI a second switch of its own.
|
|
std::env::set_var("NO_COLOR", "1");
|
|
}
|
|
squid_tui::run().context("could not open the interface")?;
|
|
Ok(0)
|
|
}
|
|
Some(Command::Clean(args)) => cmd_clean(args, cli.json),
|
|
Some(Command::Uninstall(args)) => cmd_uninstall(args, cli.json),
|
|
Some(Command::Purge(args)) => cmd_purge(args, cli.json),
|
|
Some(Command::Status(args)) => cmd_status(args, cli.json),
|
|
Some(Command::Analyze(args)) => cmd_analyze(args, cli.json),
|
|
Some(Command::History(args)) => cmd_history(args, cli.json),
|
|
Some(Command::Undo(args)) => cmd_undo(args, cli.json),
|
|
Some(Command::Whitelist(args)) => cmd_whitelist(args),
|
|
Some(Command::Rules) => cmd_rules(cli.json),
|
|
Some(Command::Doctor) => cmd_doctor(),
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------- output
|
|
|
|
fn paint(code: &str, text: &str) -> String {
|
|
if COLOR.load(Ordering::Relaxed) {
|
|
format!("\x1b[{code}m{text}\x1b[0m")
|
|
} else {
|
|
text.to_string()
|
|
}
|
|
}
|
|
|
|
fn shout(code: &str, text: &str) {
|
|
if !QUIET.load(Ordering::Relaxed) || code == "31" {
|
|
diag(code, text);
|
|
}
|
|
}
|
|
|
|
fn heading(text: &str) {
|
|
if QUIET.load(Ordering::Relaxed) {
|
|
return;
|
|
}
|
|
diag("0", "");
|
|
diag("1;36", text);
|
|
diag("90", &"─".repeat(text.chars().count().min(64)));
|
|
}
|
|
|
|
fn shrink(text: &str, width: usize) -> String {
|
|
use unicode_width::UnicodeWidthChar;
|
|
if text.chars().map(|c| c.width().unwrap_or(0)).sum::<usize>() <= width {
|
|
return text.to_string();
|
|
}
|
|
if width <= 3 {
|
|
return ".".repeat(width);
|
|
}
|
|
let mut budget = width - 3;
|
|
let mut out = String::new();
|
|
for ch in text.chars().rev() {
|
|
let wide = ch.width().unwrap_or(0);
|
|
if wide > budget {
|
|
break;
|
|
}
|
|
budget -= wide;
|
|
out.insert(0, ch);
|
|
}
|
|
format!("...{out}")
|
|
}
|
|
|
|
fn clip(text: &str, width: usize) -> String {
|
|
use unicode_width::UnicodeWidthChar;
|
|
if text.chars().map(|c| c.width().unwrap_or(0)).sum::<usize>() <= width {
|
|
return text.to_string();
|
|
}
|
|
let mut budget = width.saturating_sub(1);
|
|
let mut out = String::new();
|
|
for ch in text.chars() {
|
|
let wide = ch.width().unwrap_or(0);
|
|
if wide > budget {
|
|
break;
|
|
}
|
|
budget -= wide;
|
|
out.push(ch);
|
|
}
|
|
out.push('…');
|
|
out
|
|
}
|
|
|
|
/// [`clip`] plus space padding so the clipped text always occupies exactly
|
|
/// `width` display columns. Columns after it stay aligned.
|
|
fn fit(text: &str, width: usize) -> String {
|
|
use unicode_width::UnicodeWidthChar;
|
|
let clipped = clip(text, width);
|
|
let used: usize = clipped.chars().map(|c| c.width().unwrap_or(0)).sum();
|
|
let mut out = clipped;
|
|
out.push_str(&" ".repeat(width.saturating_sub(used)));
|
|
out
|
|
}
|
|
|
|
/// What this operating system calls the place deleted files wait in.
|
|
///
|
|
/// Windows has no Trash folder: the shell's Recycle Bin is what a user can
|
|
/// actually open, so every sentence that tells a person where a file went, or
|
|
/// how to get it back, has to use their operating system's word.
|
|
fn bin() -> &'static str {
|
|
squid_platform::current().bin_noun().en()
|
|
}
|
|
|
|
/// Visible width of a string, counting CJK glyphs as two columns.
|
|
fn display_width(text: &str) -> usize {
|
|
use unicode_width::UnicodeWidthChar;
|
|
text.chars().map(|c| c.width().unwrap_or(0)).sum()
|
|
}
|
|
|
|
/// Why this row is greyed out (or what is worth knowing about it). The item's
|
|
/// own note names the concrete reason — "no git repo and only 2 days old" —
|
|
/// which beats the generic lock label, so the note wins when both exist.
|
|
fn why(item: &CleanupItem) -> Option<String> {
|
|
if let Some(note) = item.note.as_deref() {
|
|
return Some(note.to_string());
|
|
}
|
|
item.lock.map(delete::lock_reason).map(str::to_string)
|
|
}
|
|
|
|
fn row(size: Bytes, label: &str, path: &str, note: Option<&str>) {
|
|
let terminal = terminal_width();
|
|
let label_cell = fit(label, 30);
|
|
let path_width = terminal
|
|
.saturating_sub(11 + display_width(&label_cell) + 2)
|
|
.max(16);
|
|
say(&format!(
|
|
" {} {} {}",
|
|
paint("33", &format!("{:>9}", size.human())),
|
|
paint("1", &label_cell),
|
|
paint("90", &shrink(path, path_width))
|
|
));
|
|
if let Some(note) = note {
|
|
say(&format!(
|
|
" {}",
|
|
paint("90", &format!("↳ {note}"))
|
|
));
|
|
}
|
|
}
|
|
|
|
fn terminal_width() -> usize {
|
|
crossterm::terminal::size()
|
|
.map(|(width, _)| width as usize)
|
|
.unwrap_or(100)
|
|
.clamp(60, 200)
|
|
}
|
|
|
|
fn ask(question: &str) -> bool {
|
|
if !std::io::stdin().is_tty() {
|
|
shout(
|
|
"33",
|
|
"not a terminal — pass --yes to run this without asking",
|
|
);
|
|
return false;
|
|
}
|
|
print!("{} ", priced(&paint("1;33", &format!("{question} [y/N]"))));
|
|
let _ = std::io::stdout().flush();
|
|
let mut answer = String::new();
|
|
if std::io::stdin().read_line(&mut answer).is_err() {
|
|
return false;
|
|
}
|
|
matches!(answer.trim().to_ascii_lowercase().as_str(), "y" | "yes")
|
|
}
|
|
|
|
// ----------------------------------------------------------- progress plumbing
|
|
|
|
/// Run `work` while pumping its progress events to the terminal.
|
|
fn with_progress<T>(
|
|
label: &str,
|
|
work: impl FnOnce(&Engine, &Progress, &CancelToken) -> squid_core::Result<T>,
|
|
) -> squid_core::Result<T> {
|
|
let label = label.to_owned();
|
|
let engine = Engine::new();
|
|
let progress = Progress::new();
|
|
let cancel = CancelToken::new();
|
|
let printer = progress.clone();
|
|
let stop = Arc::new(AtomicBool::new(false));
|
|
let printer_stop = stop.clone();
|
|
let printer_thread = std::thread::spawn(move || {
|
|
let mut frames = label.chars();
|
|
loop {
|
|
let stop_now = printer_stop.load(Ordering::Relaxed);
|
|
for event in printer.drain() {
|
|
match event {
|
|
Event::Phase { phase, detail } => {
|
|
shout("36", &format!(" {} {phase} — {detail}", bullet()));
|
|
}
|
|
Event::Tick {
|
|
done,
|
|
total,
|
|
subject,
|
|
} => {
|
|
if human_stream_is_tty() {
|
|
let glyph = frames
|
|
.next()
|
|
.unwrap_or_else(|| label.chars().next().unwrap_or('#'));
|
|
let text = match total {
|
|
Some(total) if total > 0 => format!(
|
|
" {glyph} {done}/{}",
|
|
squid_core::bytes::format_thousands(total)
|
|
),
|
|
_ => format!(
|
|
" {glyph} {}",
|
|
squid_core::bytes::format_thousands(done)
|
|
),
|
|
};
|
|
let tail = subject
|
|
.as_ref()
|
|
.map(|path| shrink(&paths::pretty(path), 40))
|
|
.unwrap_or_default();
|
|
live(Some(&format!(
|
|
"{} {}",
|
|
paint("36", &text),
|
|
paint("90", &tail)
|
|
)));
|
|
}
|
|
}
|
|
Event::Warning(text) => shout("33", &format!(" ! {}", clip(&text, 100))),
|
|
Event::Note(text) => shout("90", &format!(" · {}", clip(&text, 100))),
|
|
Event::Deleted { path, freed } => {
|
|
shout(
|
|
"90",
|
|
&format!(
|
|
" ✓ {} ({})",
|
|
shrink(&paths::pretty(&path), 70),
|
|
freed.human()
|
|
),
|
|
);
|
|
}
|
|
Event::Bucket { .. } | Event::Metered { .. } | Event::Done(_) => {}
|
|
}
|
|
}
|
|
if stop_now {
|
|
if human_stream_is_tty() {
|
|
live(None);
|
|
}
|
|
break;
|
|
}
|
|
std::thread::sleep(Duration::from_millis(40));
|
|
}
|
|
});
|
|
let result = work(&engine, &progress, &cancel);
|
|
stop.store(true, Ordering::Relaxed);
|
|
let _ = printer_thread.join();
|
|
result
|
|
}
|
|
|
|
fn bullet() -> String {
|
|
if COLOR.load(Ordering::Relaxed) {
|
|
"●".to_string()
|
|
} else {
|
|
"*".to_string()
|
|
}
|
|
}
|
|
|
|
/// Print a scan the CleanMyMac way: grouped, biggest first, totals last.
|
|
fn show_scan(report: &ScanReport, title: &str) {
|
|
heading(title);
|
|
if report.items.is_empty() {
|
|
shout("90", " nothing to remove — this is a good outcome");
|
|
return;
|
|
}
|
|
let mut categories: Vec<Category> = Category::ALL.to_vec();
|
|
categories.retain(|category| report.items.iter().any(|item| item.category == *category));
|
|
categories.sort_by(|a, b| {
|
|
let total_of = |category: &Category| -> u64 {
|
|
report
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.category == *category)
|
|
.map(|item| item.on_disk().as_u64())
|
|
.sum()
|
|
};
|
|
total_of(b).cmp(&total_of(a))
|
|
});
|
|
for category in categories {
|
|
let items: Vec<&CleanupItem> = report
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.category == category)
|
|
.collect();
|
|
let total: Bytes = items.iter().map(|item| item.on_disk()).sum();
|
|
say(&paint(
|
|
"1;36",
|
|
&format!(
|
|
" {} {} · {}",
|
|
TRIANGLE,
|
|
category.title(),
|
|
total.human_long()
|
|
),
|
|
));
|
|
for item in items.iter().take(18) {
|
|
row(
|
|
item.on_disk(),
|
|
&item.label,
|
|
&item.display_path(),
|
|
why(item).as_deref(),
|
|
);
|
|
}
|
|
if items.len() > 18 {
|
|
shout(
|
|
"90",
|
|
&format!(" … and {} more", items.len() - 18),
|
|
);
|
|
}
|
|
}
|
|
let selected: Bytes = report
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.map(|item| item.on_disk())
|
|
.sum();
|
|
say("");
|
|
shout(
|
|
"1",
|
|
&format!(
|
|
" {} items · {} selected · {}",
|
|
report.items.len(),
|
|
report
|
|
.items
|
|
.iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.count(),
|
|
selected.human_long()
|
|
),
|
|
);
|
|
if report.unreadable > 0 {
|
|
shout(
|
|
"90",
|
|
&format!(" {} locations could not be read", report.unreadable),
|
|
);
|
|
}
|
|
}
|
|
|
|
const TRIANGLE: &str = "▸";
|
|
|
|
/// The one place anything is ever deleted from.
|
|
fn delete_items(
|
|
items: Vec<CleanupItem>,
|
|
mode: DeleteMode,
|
|
command: &str,
|
|
) -> squid_core::Result<delete::DeleteOutcome> {
|
|
let removable: Vec<CleanupItem> = items
|
|
.into_iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.collect();
|
|
let job = DeleteJob::new(removable, mode, command);
|
|
let count = job.removable().len();
|
|
with_progress("delete", move |engine, progress, cancel| {
|
|
if !COLOR.load(Ordering::Relaxed) {
|
|
// keep the count alive for the summary line
|
|
eprintln!(
|
|
"{}",
|
|
priced(&paint("90", &format!(" removing {count} items")))
|
|
);
|
|
}
|
|
delete::execute(engine, &job, progress, cancel)
|
|
})
|
|
}
|
|
|
|
fn report_outcome(outcome: &delete::DeleteOutcome) {
|
|
let summary = &outcome.summary;
|
|
heading("Done");
|
|
let freed = summary.freed_on_disk();
|
|
// "24.31 GB freed · moved to Trash" contradicts itself: a rename inside
|
|
// one volume frees nothing until the Trash is emptied. Say which of the
|
|
// two the number is.
|
|
let (verb, where_it_went) = match summary.mode {
|
|
Some(DeleteMode::Trash) => (
|
|
"moved",
|
|
format!(
|
|
"into the {b} — still on the disk until you empty it (squid undo restores them)",
|
|
b = bin()
|
|
),
|
|
),
|
|
Some(DeleteMode::Permanent) => ("freed", "permanently deleted".to_string()),
|
|
None => ("freed", "done".to_string()),
|
|
};
|
|
shout(
|
|
"1;32",
|
|
&format!(
|
|
" {} {verb} · {} removed · {}",
|
|
freed.human_long(),
|
|
summary.removed,
|
|
where_it_went
|
|
),
|
|
);
|
|
if let Some(session) = &summary.session_id {
|
|
shout(
|
|
"90",
|
|
&format!(" session {session} — squid undo {}", session),
|
|
);
|
|
}
|
|
for (path, reason) in outcome.skipped.iter().take(8) {
|
|
shout(
|
|
"33",
|
|
&format!(" skipped {} — {reason}", paths::pretty(path)),
|
|
);
|
|
}
|
|
if summary.failed > 0 {
|
|
for error in summary.errors.iter().take(6) {
|
|
shout("31", &format!(" ! {error}"));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn mode_from(trash: bool, permanent: bool, settings: &Settings) -> DeleteMode {
|
|
if permanent {
|
|
DeleteMode::Permanent
|
|
} else if trash {
|
|
DeleteMode::Trash
|
|
} else {
|
|
settings.delete_mode
|
|
}
|
|
}
|
|
|
|
/// The document a run owes `--json` when it deleted nothing. Same shape as
|
|
/// every other run, so a script never has to special-case "nothing was
|
|
/// selected" and stdout is never empty on success.
|
|
fn empty_summary(mode: DeleteMode) -> CleanSummary {
|
|
CleanSummary {
|
|
mode: Some(mode),
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
fn mode_note(mode: DeleteMode) -> String {
|
|
match mode {
|
|
DeleteMode::Trash => {
|
|
format!(
|
|
"everything goes to the {} first — squid undo puts it back",
|
|
bin()
|
|
)
|
|
}
|
|
DeleteMode::Permanent => format!("permanent deletion: no {}, no undo", bin()),
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------- clean
|
|
|
|
fn parse_categories(values: &[String]) -> Result<Vec<Category>> {
|
|
let mut out = Vec::new();
|
|
for value in values {
|
|
for piece in value.split(',') {
|
|
let piece = piece.trim();
|
|
if piece.is_empty() {
|
|
continue;
|
|
}
|
|
let category = Category::parse(piece)
|
|
.ok_or_else(|| anyhow::anyhow!("unknown category '{piece}' — try `squid rules`"))?;
|
|
out.push(category);
|
|
}
|
|
}
|
|
Ok(out)
|
|
}
|
|
|
|
fn selected_of(items: &[CleanupItem]) -> (usize, Bytes) {
|
|
let chosen: Vec<&CleanupItem> = items
|
|
.iter()
|
|
.filter(|item| item.selected && item.lock.is_none())
|
|
.collect();
|
|
let size = chosen.iter().map(|item| item.on_disk()).sum();
|
|
(chosen.len(), size)
|
|
}
|
|
|
|
fn cmd_clean(args: CleanArgs, json: bool) -> Result<i32> {
|
|
let settings = Engine::new().settings().clone();
|
|
let mode = mode_from(args.trash, args.permanent, &settings);
|
|
let categories = parse_categories(&args.categories)?;
|
|
let options = clean::CleanOptions {
|
|
categories,
|
|
skip_admin_rules: args.user_only,
|
|
min_age_days: args.min_age,
|
|
orphans: args.orphans,
|
|
fast: false,
|
|
};
|
|
let started = std::time::Instant::now();
|
|
let report = with_progress("scan", move |engine, progress, cancel| {
|
|
let report = clean::scan(engine, &options, progress, cancel)?;
|
|
clean::publish_buckets(&report, progress);
|
|
Ok(clean::sort_for_display(report))
|
|
})?;
|
|
|
|
let (count, size) = selected_of(&report.items);
|
|
// `--json` without `--yes` promises a plan, never a deletion; a dry run
|
|
// promises the same even when `--yes` came along for the ride.
|
|
if json && (!args.yes || args.dry_run) {
|
|
println!("{}", serde_json::to_string_pretty(&report)?);
|
|
return Ok(0);
|
|
}
|
|
if !args.dry_run {
|
|
show_scan(&report, "Cleanup");
|
|
} else {
|
|
show_scan(&report, "Cleanup · dry run");
|
|
}
|
|
shout(
|
|
"90",
|
|
&format!(" scanned in {:.1}s", started.elapsed().as_secs_f64()),
|
|
);
|
|
|
|
if args.dry_run {
|
|
shout("33", " dry run — nothing was deleted");
|
|
return Ok(0);
|
|
}
|
|
if count == 0 {
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&empty_summary(mode))?);
|
|
}
|
|
shout(
|
|
"90",
|
|
" nothing is selected; use --dry-run to inspect first",
|
|
);
|
|
return Ok(0);
|
|
}
|
|
shout("90", &format!(" {}", mode_note(mode)));
|
|
if !args.yes
|
|
&& !ask(&format!(
|
|
"Delete {count} items ({}), {}",
|
|
size.human_long(),
|
|
match mode {
|
|
DeleteMode::Trash => format!("to the {}", bin()),
|
|
DeleteMode::Permanent => "permanently".to_string(),
|
|
}
|
|
))
|
|
{
|
|
shout("33", " cancelled — nothing was deleted");
|
|
return Ok(0);
|
|
}
|
|
let outcome = delete_items(report.items, mode, "squid clean")?;
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&outcome.summary)?);
|
|
} else {
|
|
report_outcome(&outcome);
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
// ------------------------------------------------------------------- uninstall
|
|
|
|
fn cmd_uninstall(args: UninstallArgs, json: bool) -> Result<i32> {
|
|
let settings = Engine::new().settings().clone();
|
|
let mode = mode_from(args.trash, args.permanent, &settings);
|
|
|
|
if args.list || args.name.is_none() {
|
|
let apps = with_progress("apps", |engine, progress, cancel| {
|
|
uninstall::scan_apps(engine, true, progress, cancel)
|
|
})?;
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&apps)?);
|
|
return Ok(0);
|
|
}
|
|
heading(&format!("Applications · {}", apps.len()));
|
|
let total: Bytes = apps.iter().map(|app| app.size).sum();
|
|
for app in &apps {
|
|
say(&format!(
|
|
" {} {} {}{} {}",
|
|
paint("33", &format!("{:>9}", app.size.human())),
|
|
paint("1", &fit(&app.name, 34)),
|
|
paint("90", &fit(app.version.as_deref().unwrap_or("—"), 12)),
|
|
if app.running {
|
|
paint("33", " running")
|
|
} else {
|
|
" ".to_string()
|
|
},
|
|
paint("90", &shrink(&paths::pretty(&app.path), 44))
|
|
));
|
|
}
|
|
say("");
|
|
shout(
|
|
"1",
|
|
&format!(" {} apps · {}", apps.len(), total.human_long()),
|
|
);
|
|
shout("90", " squid uninstall <name> builds a removal plan");
|
|
return Ok(0);
|
|
}
|
|
|
|
let query = args.name.clone().unwrap_or_default();
|
|
let found = with_progress("find", |engine, progress, cancel| {
|
|
uninstall::find(engine, &query, cancel, progress)
|
|
})?;
|
|
if found.is_empty() {
|
|
shout("31", &format!("no application matches '{query}'"));
|
|
shout("90", " try `squid uninstall --list`");
|
|
return Ok(1);
|
|
}
|
|
let app = if found.len() == 1 {
|
|
found[0].clone()
|
|
} else {
|
|
let exact = found
|
|
.iter()
|
|
.find(|app| app.name.eq_ignore_ascii_case(&query))
|
|
.or_else(|| {
|
|
found.iter().find(|app| {
|
|
app.bundle_id
|
|
.as_deref()
|
|
.map(|id| id.eq_ignore_ascii_case(&query))
|
|
.unwrap_or(false)
|
|
})
|
|
})
|
|
.cloned();
|
|
match exact {
|
|
Some(app) => app,
|
|
None => {
|
|
heading(&format!("'{query}' matches {} applications", found.len()));
|
|
for app in &found {
|
|
say(&format!(
|
|
" {} {} {}",
|
|
paint("33", &format!("{:>9}", app.size.human())),
|
|
paint("1", &clip(&app.name, 34)),
|
|
paint("90", &shrink(&paths::pretty(&app.path), 50))
|
|
));
|
|
}
|
|
shout(
|
|
"33",
|
|
" be more specific — pass part of the name or the bundle id",
|
|
);
|
|
return Ok(1);
|
|
}
|
|
}
|
|
};
|
|
|
|
let plan = with_progress("plan", {
|
|
let app = app.clone();
|
|
move |engine, progress, cancel| uninstall::build_plan(engine, &app, progress, cancel)
|
|
})?;
|
|
|
|
if json && (!args.yes || args.dry_run) {
|
|
println!("{}", serde_json::to_string_pretty(&plan)?);
|
|
return Ok(0);
|
|
}
|
|
|
|
heading(&format!("Uninstall · {}", app.name));
|
|
shout("90", &format!(" {}", paths::pretty(&app.path)));
|
|
shout(
|
|
"90",
|
|
&format!(
|
|
" {} · {}",
|
|
app.bundle_id
|
|
.clone()
|
|
.unwrap_or_else(|| "no bundle id".into()),
|
|
app.version.clone().unwrap_or_else(|| "version ?".into())
|
|
),
|
|
);
|
|
for warning in &plan.warnings {
|
|
shout("33", &format!(" ! {warning}"));
|
|
}
|
|
let (count, size) = selected_of(&plan.items);
|
|
for item in &plan.items {
|
|
row(
|
|
item.on_disk(),
|
|
if item.rule_id == "uninstall-bundle" {
|
|
"app bundle"
|
|
} else {
|
|
item.category.title()
|
|
},
|
|
&item.display_path(),
|
|
why(item).as_deref(),
|
|
);
|
|
}
|
|
say("");
|
|
shout("1", &format!(" {count} items · {}", size.human_long()));
|
|
if args.dry_run {
|
|
shout("33", " dry run — nothing was deleted");
|
|
return Ok(0);
|
|
}
|
|
shout("90", &format!(" {}", mode_note(mode)));
|
|
if !args.yes
|
|
&& !ask(&format!(
|
|
"Remove {} and {} leftover items ({})?",
|
|
app.name,
|
|
count,
|
|
size.human_long()
|
|
))
|
|
{
|
|
shout("33", " cancelled — nothing was deleted");
|
|
return Ok(0);
|
|
}
|
|
let outcome = with_progress("delete", move |engine, progress, cancel| {
|
|
uninstall::remove_plan(engine, &plan, mode, progress, cancel)
|
|
})?;
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&outcome.summary)?);
|
|
} else {
|
|
report_outcome(&outcome);
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
// ----------------------------------------------------------------------- purge
|
|
|
|
fn cmd_purge(args: PurgeArgs, json: bool) -> Result<i32> {
|
|
let settings = Engine::new().settings().clone();
|
|
let mode = mode_from(false, false, &settings);
|
|
let roots: Vec<PathBuf> = args.paths.iter().map(|path| paths::expand(path)).collect();
|
|
let options = purge::PurgeOptions {
|
|
roots,
|
|
min_age_days: args.min_age,
|
|
force: args.all,
|
|
max_depth: None,
|
|
};
|
|
if json && (!args.yes || args.dry_run) {
|
|
let report = with_progress("purge", {
|
|
let options = options.clone();
|
|
move |engine, progress, cancel| purge::scan(engine, &options, progress, cancel)
|
|
})?;
|
|
println!("{}", serde_json::to_string_pretty(&report)?);
|
|
return Ok(0);
|
|
}
|
|
let report = with_progress("purge", move |engine, progress, cancel| {
|
|
let mut report = purge::scan(engine, &options, progress, cancel)?;
|
|
report.items.sort_by(|a, b| {
|
|
b.on_disk()
|
|
.cmp(&a.on_disk())
|
|
.then_with(|| a.path.cmp(&b.path))
|
|
});
|
|
Ok(report)
|
|
})?;
|
|
show_scan(
|
|
&report,
|
|
if args.dry_run {
|
|
"Deep clean · dry run"
|
|
} else {
|
|
"Deep clean"
|
|
},
|
|
);
|
|
let snapshots = purge::local_snapshots();
|
|
if let Some(note) = purge::snapshot_note(&snapshots) {
|
|
heading("Time Machine");
|
|
shout("33", &format!(" {note}"));
|
|
for snapshot in snapshots.iter().take(6) {
|
|
shout("90", &format!(" · {}", snapshot.name));
|
|
}
|
|
shout(
|
|
"90",
|
|
" squid never touches snapshots — that is tmutil's job",
|
|
);
|
|
}
|
|
let (count, size) = selected_of(&report.items);
|
|
if args.dry_run {
|
|
shout("33", " dry run — nothing was deleted");
|
|
return Ok(0);
|
|
}
|
|
if count == 0 {
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&empty_summary(mode))?);
|
|
}
|
|
shout(
|
|
"90",
|
|
" nothing safe to remove; --all offers the ambiguous folders too",
|
|
);
|
|
return Ok(0);
|
|
}
|
|
shout("90", &format!(" {}", mode_note(mode)));
|
|
if !args.yes
|
|
&& !ask(&format!(
|
|
"Delete {count} folders ({}), {}",
|
|
size.human_long(),
|
|
match mode {
|
|
DeleteMode::Trash => format!("to the {}", bin()),
|
|
DeleteMode::Permanent => "permanently".to_string(),
|
|
}
|
|
))
|
|
{
|
|
shout("33", " cancelled — nothing was deleted");
|
|
return Ok(0);
|
|
}
|
|
let outcome = delete_items(report.items, mode, "squid purge")?;
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&outcome.summary)?);
|
|
} else {
|
|
report_outcome(&outcome);
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------- status
|
|
|
|
fn cmd_status(args: StatusArgs, json: bool) -> Result<i32> {
|
|
let mut sampler = squid_stats::Sampler::new();
|
|
let _ = sampler.prime();
|
|
std::thread::sleep(Duration::from_millis(500));
|
|
let snapshot = sampler.refresh();
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&snapshot)?);
|
|
return Ok(0);
|
|
}
|
|
heading(&format!(
|
|
"{} · {}",
|
|
snapshot.host.hostname, snapshot.host.hardware
|
|
));
|
|
let kv = |label: &str, value: String| {
|
|
row!(" {:<10} {}", paint("90", label), value);
|
|
};
|
|
kv(
|
|
"system",
|
|
format!(
|
|
"{} {} · {}",
|
|
snapshot.host.os_name, snapshot.host.os_version, snapshot.host.arch
|
|
),
|
|
);
|
|
kv("uptime", squid_stats::human_uptime(snapshot.uptime_secs));
|
|
kv(
|
|
"cpu",
|
|
format!(
|
|
"{}%",
|
|
paint(
|
|
if snapshot.cpu.total > 80.0 {
|
|
"31"
|
|
} else {
|
|
"32"
|
|
},
|
|
&format!("{:.0}", snapshot.cpu.total)
|
|
)
|
|
),
|
|
);
|
|
kv(
|
|
"load",
|
|
format!(
|
|
"{:.2} {:.2} {:.2} · {} cores · {}",
|
|
snapshot.cpu.load[0],
|
|
snapshot.cpu.load[1],
|
|
snapshot.cpu.load[2],
|
|
snapshot.cpu.logical_cores,
|
|
clip(&snapshot.cpu.brand, 28)
|
|
),
|
|
);
|
|
kv(
|
|
"memory",
|
|
format!(
|
|
"{} / {} ({}%) · swap {} / {}",
|
|
snapshot.memory.used.human_binary(),
|
|
snapshot
|
|
.memory
|
|
.installed
|
|
.max(snapshot.memory.total)
|
|
.human_binary(),
|
|
snapshot.memory.percent_used(),
|
|
snapshot.memory.swap_used.human_binary(),
|
|
snapshot.memory.swap_total.human_binary()
|
|
),
|
|
);
|
|
kv(
|
|
"network",
|
|
format!(
|
|
"↓ {}/s ↑ {}/s · since boot {}",
|
|
snapshot.network.rx_per_sec.human(),
|
|
snapshot.network.tx_per_sec.human(),
|
|
(snapshot.network.rx_total + snapshot.network.tx_total).human()
|
|
),
|
|
);
|
|
kv(
|
|
"disk",
|
|
format!(
|
|
"↓ {}/s ↑ {}/s · {:.1}% active",
|
|
snapshot.disk.read_per_sec.human(),
|
|
snapshot.disk.write_per_sec.human(),
|
|
snapshot.disk.activity
|
|
),
|
|
);
|
|
if let Some(battery) = &snapshot.battery {
|
|
kv("battery", battery.label());
|
|
}
|
|
heading("Volumes");
|
|
for volume in &snapshot.volumes {
|
|
let used = volume.used();
|
|
let width = 28usize;
|
|
let ratio = if volume.total.as_u64() == 0 {
|
|
0.0
|
|
} else {
|
|
used.as_u64() as f64 / volume.total.as_u64() as f64
|
|
};
|
|
let filled = (ratio * width as f64).round() as usize;
|
|
let bar = format!(
|
|
"{}{}",
|
|
paint("36", &"█".repeat(filled)),
|
|
paint("90", &"░".repeat(width - filled))
|
|
);
|
|
row!(
|
|
" {} [{}] {} / {} {}",
|
|
paint("1", &fit(&volume.name, 14)),
|
|
bar,
|
|
paint("32", &used.human()),
|
|
volume.total.human(),
|
|
paint("90", &format!("{} free", volume.free.human()))
|
|
);
|
|
}
|
|
heading(&format!("Top processes · {}", args.processes));
|
|
for process in snapshot.top_processes.iter().take(args.processes) {
|
|
row!(
|
|
" {:>6} {} {:>9} {}",
|
|
paint("36", &format!("{:.1}%", process.cpu)),
|
|
paint("1", &fit(&process.name, 30)),
|
|
paint("33", &process.memory.human()),
|
|
paint("90", &format!("pid {}", process.pid))
|
|
);
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
// --------------------------------------------------------------------- analyze
|
|
|
|
fn cmd_analyze(args: AnalyzeArgs, json: bool) -> Result<i32> {
|
|
let root = args
|
|
.path
|
|
.as_deref()
|
|
.map(paths::expand)
|
|
.unwrap_or_else(paths::home_dir);
|
|
if !root.is_dir() {
|
|
anyhow::bail!("{} is not a folder", root.display());
|
|
}
|
|
let node = with_progress("map", {
|
|
let root = root.clone();
|
|
let depth = args.depth;
|
|
let top = args.top;
|
|
move |engine, progress, cancel| {
|
|
let _ = engine;
|
|
analyze::explore(&root, depth, top, cancel, progress)
|
|
}
|
|
})?;
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&node)?);
|
|
return Ok(0);
|
|
}
|
|
heading(&format!(
|
|
"{} · {}",
|
|
paths::pretty(&node.path),
|
|
node.size().human_long()
|
|
));
|
|
print_tree(&node, 0, &node.size());
|
|
if !node.complete {
|
|
shout(
|
|
"90",
|
|
" (the walk hit its limit — the totals are a floor, not the truth)",
|
|
);
|
|
}
|
|
if args.files {
|
|
let files = with_progress("files", {
|
|
let root = root.clone();
|
|
move |engine, progress, cancel| {
|
|
let _ = engine;
|
|
analyze::largest_files(&root, 20, Bytes(10 * 1024 * 1024), cancel, progress)
|
|
}
|
|
})?;
|
|
heading("Largest files");
|
|
for file in &files {
|
|
row(
|
|
file.size(),
|
|
&paths::label_for(&file.path),
|
|
&paths::pretty(&file.path),
|
|
None,
|
|
);
|
|
}
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
fn print_tree(node: &analyze::Node, depth: usize, total: &Bytes) {
|
|
let width = 22usize;
|
|
let bar_w = (terminal_width() as i64 - 34 - depth as i64 * 2).clamp(6, 30) as usize;
|
|
for child in node.display_children().iter().take(40) {
|
|
let size = child.size();
|
|
let ratio = if total.is_zero() {
|
|
0.0
|
|
} else {
|
|
size.as_u64() as f64 / total.as_u64() as f64
|
|
};
|
|
let filled = (ratio * bar_w as f64).round() as usize;
|
|
let bar = format!(
|
|
"{}{}",
|
|
paint("35", &"█".repeat(filled)),
|
|
paint("90", &"░".repeat(bar_w.saturating_sub(filled)))
|
|
);
|
|
row!(
|
|
" {}{} [{}] {} {:>4.1}%",
|
|
" ".repeat(depth),
|
|
paint("1", &fit(&child.name(), width)),
|
|
bar,
|
|
paint("33", &format!("{:>8}", size.human())),
|
|
ratio * 100.0
|
|
);
|
|
if depth + 1 < 2 {
|
|
print_tree(child, depth + 1, total);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------- history / undo
|
|
|
|
/// What a run did to its bytes, in one word. A run the user restored gets its
|
|
/// own label: still calling it "to Trash" after an undo is how the ledger
|
|
/// starts telling a story that no longer happened.
|
|
fn mode_label(session: &squid_core::ledger::Session) -> String {
|
|
if session.restored {
|
|
"restored".to_string()
|
|
} else {
|
|
match session.mode {
|
|
DeleteMode::Trash => format!("to {}", bin()),
|
|
DeleteMode::Permanent => "for good".to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Width of the mode column in `history`: the operating system's own word has
|
|
/// to fit there, and "to Recycle Bin" is wider than "to Trash".
|
|
fn mode_col_width() -> usize {
|
|
format!("to {}", bin()).len().max(9)
|
|
}
|
|
|
|
fn cmd_history(args: HistoryArgs, json: bool) -> Result<i32> {
|
|
let sessions = squid_core::ledger::load_sessions(args.limit);
|
|
if json {
|
|
println!("{}", serde_json::to_string_pretty(&sessions)?);
|
|
return Ok(0);
|
|
}
|
|
heading(&format!("History · {} sessions", sessions.len()));
|
|
if sessions.is_empty() {
|
|
shout(
|
|
"90",
|
|
&format!(
|
|
" nothing yet — the ledger lives in {}",
|
|
paths::pretty(&squid_core::ledger::history_dir())
|
|
),
|
|
);
|
|
return Ok(0);
|
|
}
|
|
let mut freed = Bytes::ZERO;
|
|
let mut trashed = Bytes::ZERO;
|
|
let mut undone = 0;
|
|
for session in &sessions {
|
|
// `kept`, not `freed`: a session the user already restored put every
|
|
// byte back, and a total that counts it twice overstates the space.
|
|
let reclaimed = session.kept();
|
|
freed += reclaimed;
|
|
if session.restored {
|
|
undone += 1;
|
|
}
|
|
if session.mode == DeleteMode::Trash {
|
|
// A rename into ~/.Trash is on the same volume, so the bytes are
|
|
// still on the disk. Counting them as "freed" is how a correct
|
|
// number comes to look like a broken one.
|
|
trashed += reclaimed;
|
|
}
|
|
let failures = if session.failed > 0 {
|
|
paint("33", &format!(" · {} failed", session.failed))
|
|
} else {
|
|
String::new()
|
|
};
|
|
row!(
|
|
" {} {} {} {} {} {}",
|
|
paint(
|
|
"90",
|
|
&fit(
|
|
session
|
|
.started
|
|
.replace('T', " ")
|
|
.split('+')
|
|
.next()
|
|
.and_then(|stamp| stamp.split('.').next())
|
|
.unwrap_or(&session.started),
|
|
19
|
|
)
|
|
),
|
|
paint("1", &fit(&session.command, 20)),
|
|
paint("32", &format!("{:>11}", session.freed().human_fixed())),
|
|
paint(
|
|
"33",
|
|
&format!(
|
|
"{:>14} removed",
|
|
squid_core::bytes::format_thousands(session.removed as u64)
|
|
),
|
|
),
|
|
paint(
|
|
"90",
|
|
&format!(
|
|
"{}{}",
|
|
fit(&mode_label(session), mode_col_width()),
|
|
failures
|
|
)
|
|
),
|
|
paint("90", &shrink(&session.id, 18))
|
|
);
|
|
}
|
|
println!();
|
|
shout(
|
|
"1",
|
|
&format!(
|
|
" {} removed across {} sessions",
|
|
freed.human_long(),
|
|
sessions.len()
|
|
),
|
|
);
|
|
if !trashed.is_zero() {
|
|
shout(
|
|
"90",
|
|
&format!(
|
|
" {} of it is sitting in the {b} — empty the {b} to actually reclaim it",
|
|
trashed.human_long(),
|
|
b = bin()
|
|
),
|
|
);
|
|
}
|
|
if undone > 0 {
|
|
shout(
|
|
"90",
|
|
&format!(" {undone} session(s) were restored afterwards and are counted as nothing"),
|
|
);
|
|
}
|
|
shout(
|
|
"90",
|
|
&format!(" {}", paths::pretty(&squid_core::ledger::history_dir())),
|
|
);
|
|
shout(
|
|
"90",
|
|
&format!(
|
|
" squid undo restores the newest session that went to the {}",
|
|
bin()
|
|
),
|
|
);
|
|
Ok(0)
|
|
}
|
|
|
|
fn cmd_undo(args: UndoArgs, json: bool) -> Result<i32> {
|
|
let id = match args.session {
|
|
Some(id) => id,
|
|
None => {
|
|
let sessions = squid_core::ledger::load_sessions(40);
|
|
match sessions
|
|
.iter()
|
|
.find(|session| session.mode == DeleteMode::Trash && !session.entries.is_empty())
|
|
{
|
|
Some(session) => session.id.clone(),
|
|
None => {
|
|
shout("33", &format!("no deletions in the {} to restore", bin()));
|
|
return Ok(0);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
// Whether squid kept a path it can rename back is a property of the
|
|
// session's mode, so read it from the ledger rather than guessing.
|
|
let trashed = squid_core::ledger::load_session(&id)
|
|
.map(|session| session.mode == DeleteMode::Trash)
|
|
.unwrap_or(false);
|
|
let (restored, skipped) =
|
|
delete::restore_session(&id).with_context(|| format!("could not restore session {id}"))?;
|
|
if json {
|
|
println!(
|
|
"{}",
|
|
serde_json::json!({ "session": id, "restored": restored, "skipped": skipped })
|
|
);
|
|
} else {
|
|
shout(
|
|
"1;32",
|
|
&format!("{restored} items restored from session {id}"),
|
|
);
|
|
if skipped > 0 {
|
|
// Trash mode on Windows moves the bytes into the shell's Recycle
|
|
// Bin, which keeps them under its own names — squid never has a
|
|
// path to rename back. Saying "path in use" there blamed the user
|
|
// for a restore that was never squid's to perform.
|
|
let shell_owns_it = trashed
|
|
&& matches!(
|
|
Engine::new().platform().trash_target(),
|
|
TrashTarget::RecycleBin
|
|
);
|
|
if shell_owns_it {
|
|
shout(
|
|
"90",
|
|
&format!("{skipped} are in the Recycle Bin — restore them there"),
|
|
);
|
|
} else {
|
|
shout(
|
|
"90",
|
|
&format!("{skipped} could not be put back (path in use)"),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
// ------------------------------------------------------ whitelist / rules / doctor
|
|
|
|
fn cmd_whitelist(args: WhitelistArgs) -> Result<i32> {
|
|
let (mut settings, errors) = Settings::load();
|
|
for error in errors {
|
|
shout("33", &format!("config: {error}"));
|
|
}
|
|
match args.action {
|
|
WhitelistAction::Add { paths: values } => {
|
|
if values.is_empty() {
|
|
anyhow::bail!("nothing to protect — pass one or more paths or globs");
|
|
}
|
|
for value in values {
|
|
let pattern = value.replace('~', &paths::home_dir().to_string_lossy());
|
|
shout("32", &format!("protected {pattern}"));
|
|
settings.add_whitelist(pattern);
|
|
}
|
|
}
|
|
WhitelistAction::Remove { paths: values } => {
|
|
for value in values {
|
|
let pattern = value.replace('~', &paths::home_dir().to_string_lossy());
|
|
if settings.remove_whitelist(&pattern) {
|
|
shout("33", &format!("unprotected {pattern}"));
|
|
} else {
|
|
shout("90", &format!("{pattern} was not protected"));
|
|
}
|
|
}
|
|
}
|
|
WhitelistAction::List => {
|
|
heading("Whitelist");
|
|
if settings.whitelist.is_empty() {
|
|
shout("90", " empty — every matching path is offered for review");
|
|
}
|
|
for pattern in &settings.whitelist {
|
|
row!(" {} {}", paint("32", "●"), pattern);
|
|
}
|
|
println!();
|
|
shout("90", &format!(" {}", paths::pretty(&Settings::path())));
|
|
return Ok(0);
|
|
}
|
|
}
|
|
let path = settings.save()?;
|
|
shout("90", &format!("saved {}", paths::pretty(&path)));
|
|
Ok(0)
|
|
}
|
|
|
|
fn cmd_rules(json: bool) -> Result<i32> {
|
|
let engine = Engine::new();
|
|
let rules = squid_rules::RuleSet::load(engine.settings());
|
|
if json {
|
|
let view: Vec<serde_json::Value> = rules
|
|
.rules()
|
|
.iter()
|
|
.map(|rule| {
|
|
serde_json::json!({
|
|
"id": rule.id,
|
|
"category": rule.category.id(),
|
|
"title": rule.title,
|
|
"os": rule.os,
|
|
"needs_admin": rule.needs_admin,
|
|
"risky": rule.risky,
|
|
"note": rule.note,
|
|
"min_age_days": rule.min_age_days,
|
|
"select_by_default": rule.select_by_default,
|
|
"enabled": engine.settings().rule_enabled(&rule.id),
|
|
"patterns": rule.patterns,
|
|
})
|
|
})
|
|
.collect();
|
|
println!("{}", serde_json::to_string_pretty(&view)?);
|
|
return Ok(0);
|
|
}
|
|
for category in rules.categories() {
|
|
let list = rules.by_category(category);
|
|
println!();
|
|
row!(
|
|
"{}",
|
|
paint(
|
|
"1;36",
|
|
&format!(" {} · {}", category.title(), category.blurb())
|
|
)
|
|
);
|
|
for rule in list {
|
|
let enabled = engine.settings().rule_enabled(&rule.id);
|
|
let mut flags = Vec::new();
|
|
if !enabled {
|
|
flags.push(paint("31", "off"));
|
|
}
|
|
if rule.needs_admin && !squid_engine::is_root() {
|
|
flags.push(paint("33", "admin"));
|
|
}
|
|
if rule.risky {
|
|
flags.push(paint("31", "risky"));
|
|
}
|
|
if rule.min_age_days > 0 {
|
|
flags.push(paint("90", &format!(">{}d", rule.min_age_days)));
|
|
}
|
|
if !rule.select_by_default {
|
|
flags.push(paint("90", "opt-in"));
|
|
}
|
|
row!(
|
|
" {} {:<28} {}",
|
|
if enabled {
|
|
paint("32", "●")
|
|
} else {
|
|
paint("31", "○")
|
|
},
|
|
rule.id,
|
|
paint("90", rule.display_title())
|
|
);
|
|
if !flags.is_empty() {
|
|
row!(" {}", flags.join(" "));
|
|
}
|
|
}
|
|
}
|
|
println!();
|
|
shout(
|
|
"90",
|
|
&format!(
|
|
" {} rules · disable one with `squid rules` docs or settings.toml disabled_rules",
|
|
rules.len()
|
|
),
|
|
);
|
|
for error in rules.errors() {
|
|
shout("31", &format!(" ! {error}"));
|
|
}
|
|
Ok(0)
|
|
}
|
|
|
|
fn cmd_doctor() -> Result<i32> {
|
|
let engine = Engine::new();
|
|
let platform = engine.platform();
|
|
heading("squid doctor");
|
|
let kv = |label: &str, value: String| row!(" {:<12} {}", paint("90", label), value);
|
|
kv("version", squid_core::VERSION.to_string());
|
|
kv("platform", platform.display_name());
|
|
kv("os", platform.os_version());
|
|
kv("hardware", platform.hardware_model());
|
|
kv(
|
|
"privileges",
|
|
if squid_engine::is_root() {
|
|
paint("33", "root — every path is offered, be careful")
|
|
} else {
|
|
format!(
|
|
"{} (user-owned paths only)",
|
|
std::env::var("USER").unwrap_or_else(|_| "standard".into())
|
|
)
|
|
},
|
|
);
|
|
kv(
|
|
"config",
|
|
format!(
|
|
"{} {}",
|
|
paths::pretty(&Settings::path()),
|
|
if Settings::path().exists() {
|
|
"(present)"
|
|
} else {
|
|
"(defaults — created on first save)"
|
|
}
|
|
),
|
|
);
|
|
let (locale, source) = Locale::explain(engine.settings());
|
|
kv(
|
|
"language",
|
|
format!("{} — decided by {}", locale.code(), source.describe()),
|
|
);
|
|
// The other half of "it looks wrong in this terminal": squid only paints
|
|
// 24-bit colour where the host said it can parse it, so `TERM`/`COLORTERM`
|
|
// are worth printing next to the answer they produced.
|
|
let mode = squid_tui::theme::color_mode();
|
|
kv(
|
|
"colour",
|
|
format!(
|
|
"{} — probed from TERM={} COLORTERM={} TERM_PROGRAM={}",
|
|
mode.label(),
|
|
std::env::var("TERM").unwrap_or_else(|_| "(unset)".into()),
|
|
std::env::var("COLORTERM").unwrap_or_else(|_| "(unset)".into()),
|
|
std::env::var("TERM_PROGRAM").unwrap_or_else(|_| "(unset)".into()),
|
|
),
|
|
);
|
|
for error in engine.settings_errors() {
|
|
shout("31", &format!(" ! {error}"));
|
|
}
|
|
let probe = Settings::config_dir().join(".squid-write-probe");
|
|
let writable = std::fs::create_dir_all(Settings::config_dir()).is_ok()
|
|
&& std::fs::write(&probe, b"ok").is_ok();
|
|
let _ = std::fs::remove_file(&probe);
|
|
kv(
|
|
"writable",
|
|
if writable {
|
|
paint("32", "yes — settings and ledger can be written")
|
|
} else {
|
|
paint("31", "no — check ownership of ~/.config/squid")
|
|
},
|
|
);
|
|
let rules = squid_rules::RuleSet::load(engine.settings());
|
|
kv("rules", format!("{} loaded", rules.len()));
|
|
kv(
|
|
"delete mode",
|
|
match engine.settings().delete_mode {
|
|
DeleteMode::Trash => format!("{} (undo available)", bin()),
|
|
DeleteMode::Permanent => "permanent".to_string(),
|
|
},
|
|
);
|
|
let sessions = squid_core::ledger::load_sessions(500);
|
|
let freed: Bytes = sessions.iter().map(|session| session.freed()).sum();
|
|
kv(
|
|
"ledger",
|
|
format!(
|
|
"{} sessions · {} · {}",
|
|
sessions.len(),
|
|
freed.human_long(),
|
|
paths::pretty(&squid_core::ledger::history_dir())
|
|
),
|
|
);
|
|
// Ask the platform, not the filesystem: Windows has no ~/.Trash yet its
|
|
// Recycle Bin works, and claiming otherwise made people think Trash mode
|
|
// was silently permanent.
|
|
let trash = match platform.trash_target() {
|
|
TrashTarget::RecycleBin => paint("32", "Recycle Bin — restorable from Windows itself"),
|
|
TrashTarget::Folder(dir) => paint("32", &format!("reachable ({})", paths::pretty(&dir))),
|
|
TrashTarget::Unreachable => paint(
|
|
"33",
|
|
&format!("no {} here — deletions fall back to permanent", bin()),
|
|
),
|
|
};
|
|
kv("trash", trash);
|
|
let volumes = platform.volumes().unwrap_or_default();
|
|
kv("volumes", format!("{}", volumes.len()));
|
|
for volume in &volumes {
|
|
row!(
|
|
" {} {}",
|
|
paint("1", &fit(&volume.name, 16)),
|
|
paint(
|
|
"90",
|
|
&format!("{} free of {}", volume.free.human(), volume.total.human())
|
|
)
|
|
);
|
|
}
|
|
let mut probes = vec![
|
|
paths::home_dir().join("Library/Caches"),
|
|
Path::new("/Applications").to_path_buf(),
|
|
paths::home_dir().join("Library/Safari"),
|
|
paths::home_dir().join("Library/Mail"),
|
|
];
|
|
if let Some(volume) = volumes.iter().find(|volume| volume.is_root) {
|
|
probes.push(volume.mount_point.join("Library/Application Support"));
|
|
}
|
|
let blocked: Vec<String> = probes
|
|
.into_iter()
|
|
.filter(|path| path.exists() && std::fs::read_dir(path).is_err())
|
|
.map(|path| paths::pretty(&path))
|
|
.collect();
|
|
if blocked.is_empty() {
|
|
kv("access", paint("32", "every probe folder is readable"));
|
|
} else {
|
|
kv(
|
|
"access",
|
|
paint(
|
|
"33",
|
|
"some folders are blocked — grant Full Disk Access to your terminal",
|
|
),
|
|
);
|
|
for path in blocked {
|
|
shout("90", &format!(" {path}"));
|
|
}
|
|
}
|
|
println!();
|
|
shout(
|
|
"90",
|
|
&format!(" safety: {}", mode_note(engine.settings().delete_mode)),
|
|
);
|
|
Ok(0)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod chrome {
|
|
use squid_platform::console::Prices;
|
|
use squid_platform::currency::{self, Exchange};
|
|
use unicode_width::UnicodeWidthStr;
|
|
|
|
/// The source with its strings, character literals and comments blanked, so
|
|
/// that a scan of the program is not a scan of its prose — which matters
|
|
/// more here than in most programs, because half of this file is sentences
|
|
/// about what it prints, and they quote the characters they describe.
|
|
fn only_code(source: &str) -> String {
|
|
let chars: Vec<char> = source.chars().collect();
|
|
let mut code = String::with_capacity(source.len());
|
|
let mut index = 0;
|
|
while index < chars.len() {
|
|
match chars[index] {
|
|
'/' if chars.get(index + 1) == Some(&'/') => {
|
|
while index < chars.len() && chars[index] != '\n' {
|
|
code.push(' ');
|
|
index += 1;
|
|
}
|
|
}
|
|
// A double quote always opens a string. A single quote only
|
|
// opens a character literal, and closes again almost immediately
|
|
// when it does; otherwise it is a lifetime, and blanking from a
|
|
// lifetime to the next quote is how a print site vanishes from
|
|
// an audit whose entire job is to find print sites.
|
|
quote @ ('"' | '\'') if quote == '"' || closes_char_literal(&chars, index) => {
|
|
code.push(' ');
|
|
index += 1;
|
|
while index < chars.len() {
|
|
if chars[index] == '\\' {
|
|
code.push(' ');
|
|
index += 2;
|
|
continue;
|
|
}
|
|
code.push(' ');
|
|
index += 1;
|
|
if chars[index - 1] == quote {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
ch => {
|
|
code.push(ch);
|
|
index += 1;
|
|
}
|
|
}
|
|
}
|
|
code
|
|
}
|
|
|
|
/// Whether the single quote at `open` opens a character literal.
|
|
///
|
|
/// `'q'`, `'\n'` and `'\u{1F600}'` all close inside a few characters, which
|
|
/// is what this asks; `'static`, `'a mut` and the apostrophe of a prose word
|
|
/// that escaped the comment blanker do not, so they stay where they are.
|
|
fn closes_char_literal(chars: &[char], open: usize) -> bool {
|
|
let mut index = open + 1;
|
|
while index < chars.len() && index - open <= 12 {
|
|
if chars[index] == '\\' {
|
|
index += 2;
|
|
continue;
|
|
}
|
|
if chars[index] == '\'' {
|
|
return true;
|
|
}
|
|
index += 1;
|
|
}
|
|
false
|
|
}
|
|
|
|
/// The index just past the parenthesis that closes the one at `open`.
|
|
fn closed(code: &str, open: usize) -> Option<usize> {
|
|
let mut depth = 0;
|
|
for (offset, ch) in code[open..].char_indices() {
|
|
match ch {
|
|
'(' => depth += 1,
|
|
')' => {
|
|
depth -= 1;
|
|
if depth == 0 {
|
|
return Some(open + offset);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
/// Every line a person is shown pays for its chrome, and the only lines that
|
|
/// do not are JSON and blank ones.
|
|
///
|
|
/// The rule is about the printing rather than the characters: a `█` is
|
|
/// nothing to be ashamed of, and this program is full of them. It is
|
|
/// `println!` that owes the console an answer, because that is the moment a
|
|
/// measured row becomes a row of cells. So every print of this file either
|
|
/// goes through [`priced`] — directly, or as a [`row!`], which is the same
|
|
/// thing with the format arguments left where they were written — or prints
|
|
/// JSON, which is data: rewriting a person's report to flatter their
|
|
/// terminal is a different bug with the same fingerprint.
|
|
///
|
|
/// The scan reads the source because the mistake it looks for cannot be seen
|
|
/// from the machine it was made on. `println!(" {}", plan)` standing among
|
|
/// twelve `row!` calls is invisible on every terminal that charges one cell
|
|
/// for everything, including the one it was typed on, and arrives as a
|
|
/// report folded over on itself in front of somebody else.
|
|
#[test]
|
|
fn no_line_of_chrome_escapes_the_counter() {
|
|
let code = only_code(include_str!("main.rs"));
|
|
let mut offenders = Vec::new();
|
|
for call in ["println!(", "eprintln!(", "print!("] {
|
|
let mut from = 0;
|
|
while let Some(found) = code[from..].find(call) {
|
|
let at = from + found;
|
|
from = at + call.len();
|
|
let Some(end) = closed(&code, at + call.len() - 1) else {
|
|
continue;
|
|
};
|
|
let group = code[at + call.len()..end].trim();
|
|
if group.is_empty() || group.contains("serde_json") || group.contains("priced") {
|
|
continue;
|
|
}
|
|
offenders.push(group.to_string());
|
|
}
|
|
}
|
|
assert!(
|
|
offenders.is_empty(),
|
|
"{} print site(s) print a line nobody priced: {offenders:?}",
|
|
offenders.len()
|
|
);
|
|
}
|
|
|
|
/// What a console that reprices things charges for a line, which is not what
|
|
/// `format!` billed for it: the layout counts a `█` as the one column it
|
|
/// measured, and the glass charges two.
|
|
fn charged(text: &str) -> usize {
|
|
text.chars()
|
|
.map(|ch| 1 + currency::disputed(ch) as usize)
|
|
.sum()
|
|
}
|
|
|
|
#[test]
|
|
fn a_report_row_is_as_long_as_the_row_was_billed_for() {
|
|
// The disk row from `squid status`, built the way the command builds it.
|
|
// The row is the whole complaint: nobody called the gauge too ugly, they
|
|
// called the table unreadable, and the table is unreadable because this
|
|
// row is a screen and a half long on the glass it is printed on.
|
|
let row = format!(
|
|
" {:<14} [{}{}] 212.4 GB / 460 GB 247.6 GB free",
|
|
"Macintosh HD",
|
|
"█".repeat(20),
|
|
"░".repeat(8)
|
|
);
|
|
// Every character is one column to the layout, so the row is as many
|
|
// columns as it is characters — and twenty-eight of those characters are
|
|
// the gauge, which is what the console doubles.
|
|
assert_eq!(row.width(), row.chars().count());
|
|
assert_eq!(
|
|
charged(&row),
|
|
row.width() + 28,
|
|
"the row has to be overcharged before the exchange is worth testing"
|
|
);
|
|
|
|
let paid = Exchange::new(Prices::implied(936)).afford(&row);
|
|
assert_eq!(
|
|
charged(&paid),
|
|
paid.width(),
|
|
"a console may not charge for a cell the row did not pay for"
|
|
);
|
|
assert!(
|
|
paid.contains("Macintosh HD") && paid.contains("212.4 GB"),
|
|
"the row still says what it said: {paid}"
|
|
);
|
|
}
|
|
}
|