// Ported from ninja v1.13.2 src/clean.cc (Apache-2.0, see NOTICE).
///|
/// Removes built files: `ninja -t clean` and `-t cleandead` (ninja's
/// `Cleaner`). Each `clean_*` method returns 0, or 1 if something could not
/// be removed or was not found.
pub struct Cleaner {
state : State
config : BuildConfig
disk : &Disk
/// Reads dyndep files, which may name more outputs.
reader : &FileReader?
terminal : &Terminal?
removed : Map[String, Unit]
cleaned : Map[Int32, Unit]
mut cleaned_files_count : Int32
mut status : Int32
}
///|
pub fn Cleaner::new(
state : State,
config : BuildConfig,
disk : &Disk,
reader? : &FileReader,
terminal? : &Terminal,
) -> Cleaner {
{
state,
config,
disk,
reader,
terminal,
removed: Map([]),
cleaned: Map([]),
cleaned_files_count: 0,
status: 0,
}
}
///|
pub fn Cleaner::cleaned_files_count(self : Cleaner) -> Int32 {
self.cleaned_files_count
}
///|
fn Cleaner::print(self : Cleaner, text : String) -> Unit {
if self.terminal is Some(terminal) {
terminal.write_out(text)
}
}
///|
fn Cleaner::error(self : Cleaner, message : String) -> Unit {
if self.terminal is Some(terminal) {
terminal.write_err("ninja: error: \{message}\n")
}
}
///|
fn Cleaner::is_verbose(self : Cleaner) -> Bool {
!(self.config.verbosity is Quiet) &&
(self.config.verbosity is Verbose || self.config.dry_run)
}
///|
fn Cleaner::file_exists(self : Cleaner, path : String) -> Bool {
let mtime = self.disk.stat(path) catch {
error => {
self.error(error.message())
-1
}
}
// A failed stat counts as "does not exist".
mtime > 0
}
///|
fn Cleaner::report(self : Cleaner, path : String) -> Unit {
self.cleaned_files_count += 1
if self.is_verbose() {
self.print("Remove \{path}\n")
}
}
///|
fn Cleaner::remove(self : Cleaner, path : String) -> Unit {
if self.removed.contains(path) {
return
}
self.removed[path] = ()
if self.config.dry_run {
if self.file_exists(path) {
self.report(path)
}
} else {
match self.disk.remove_file(path) {
0 => self.report(path)
-1 => self.status = 1
_ => ()
}
}
}
///|
fn Cleaner::remove_edge_files(self : Cleaner, edge : Edge) -> Unit {
let depfile = edge.get_unescaped_depfile() catch { _ => "" }
if depfile != "" {
self.remove(depfile)
}
let rspfile = edge.get_unescaped_rspfile() catch { _ => "" }
if rspfile != "" {
self.remove(rspfile)
}
}
///|
fn Cleaner::print_header(self : Cleaner) -> Unit {
if self.config.verbosity is Quiet {
return
}
self.print(if self.is_verbose() { "Cleaning...\n" } else { "Cleaning... " })
}
///|
fn Cleaner::print_footer(self : Cleaner) -> Unit {
if self.config.verbosity is Quiet {
return
}
self.print("\{self.cleaned_files_count} files.\n")
}
///|
fn Cleaner::reset(self : Cleaner) -> Unit {
self.status = 0
self.cleaned_files_count = 0
self.removed.clear()
self.cleaned.clear()
}
///|
/// Loads the dyndep files that exist before cleaning them: they may name
/// more outputs. Errors are ignored; we clean what we know.
fn Cleaner::load_dyndeps(self : Cleaner) -> Unit {
guard self.reader is Some(reader) else { return }
for edge in self.state.edges {
if edge.dyndep is Some(dyndep) && dyndep.dyndep_pending {
load_dyndeps(self.state, reader, dyndep) catch {
_ => ()
}
}
}
}
///|
/// Removes every output but phony ones, and generator outputs unless
/// `generator` is set.
pub fn Cleaner::clean_all(self : Cleaner, generator~ : Bool = false) -> Int32 {
self.reset()
self.print_header()
self.load_dyndeps()
for edge in self.state.edges {
if edge.is_phony() {
continue
}
if !generator && (edge.get_binding_bool("generator") catch { _ => false }) {
continue
}
for out in edge.outputs {
self.remove(out.path)
}
self.remove_edge_files(edge)
}
self.print_footer()
self.status
}
///|
/// Removes the build log's outputs that the manifest no longer mentions.
pub fn Cleaner::clean_dead(
self : Cleaner,
entries : Map[String, LogEntry],
) -> Int32 {
self.reset()
self.print_header()
self.load_dyndeps()
for path, _ in entries {
// Stale: not in the graph at all, or only through an old deps log
// entry, neither built nor used.
match self.state.lookup_node(path) {
None => self.remove(path)
Some(node) =>
if node.in_edge is None && node.out_edges.is_empty() {
self.remove(path)
}
}
}
self.print_footer()
self.status
}
///|
fn Cleaner::do_clean_target(self : Cleaner, target : Node) -> Unit {
if target.in_edge is Some(edge) {
if !edge.is_phony() {
self.remove(target.path)
self.remove_edge_files(edge)
}
for input in edge.inputs {
if !self.cleaned.contains(input.index) {
self.do_clean_target(input)
}
}
}
self.cleaned[target.index] = ()
}
///|
/// Removes `target` and everything it is built from.
pub fn Cleaner::clean_target_node(self : Cleaner, target : Node) -> Int32 {
self.reset()
self.print_header()
self.load_dyndeps()
self.do_clean_target(target)
self.print_footer()
self.status
}
///|
pub fn Cleaner::clean_target(self : Cleaner, target : String) -> Int32 {
self.reset()
match self.state.lookup_node(target) {
Some(node) => ignore(self.clean_target_node(node))
None => {
self.error("unknown target '\{target}'")
self.status = 1
}
}
self.status
}
///|
pub fn Cleaner::clean_targets(self : Cleaner, targets : Array[String]) -> Int32 {
self.reset()
self.print_header()
self.load_dyndeps()
for name in targets {
if name == "" {
self.error("failed to canonicalize '': empty path")
self.status = 1
continue
}
let (path, _) = canonicalize_path(name, platform=self.state.platform)
match self.state.lookup_node(path) {
Some(target) => {
if self.is_verbose() {
self.print("Target \{path}\n")
}
self.do_clean_target(target)
}
None => {
self.error("unknown target '\{path}'")
self.status = 1
}
}
}
self.print_footer()
self.status
}
///|
fn Cleaner::do_clean_rule(self : Cleaner, rule : Rule) -> Unit {
for edge in self.state.edges {
if edge.rule.name == rule.name {
for out in edge.outputs {
self.remove(out.path)
self.remove_edge_files(edge)
}
}
}
}
///|
pub fn Cleaner::clean_rule(self : Cleaner, name : String) -> Int32 {
self.reset()
match self.state.bindings.lookup_rule(name) {
Some(rule) => {
self.print_header()
self.load_dyndeps()
self.do_clean_rule(rule)
self.print_footer()
}
None => {
self.error("unknown rule '\{name}'")
self.status = 1
}
}
self.status
}
///|
pub fn Cleaner::clean_rules(self : Cleaner, names : Array[String]) -> Int32 {
self.reset()
self.print_header()
self.load_dyndeps()
for name in names {
match self.state.bindings.lookup_rule(name) {
Some(rule) => {
if self.is_verbose() {
self.print("Rule \{name}\n")
}
self.do_clean_rule(rule)
}
None => {
self.error("unknown rule '\{name}'")
self.status = 1
}
}
}
self.print_footer()
self.status
}