nu_command/filesystem/

rm.rs

use super::util::try_interaction;
use nu_engine::command_prelude::*;
use nu_glob::MatchOptions;
use nu_path::expand_path_with;
use nu_protocol::{
    NuGlob, report_shell_error,
    shell_error::{self, generic::GenericError, io::IoError},
};
#[cfg(unix)]
use std::os::unix::prelude::FileTypeExt;
use std::{collections::HashMap, io::Error, path::PathBuf};

const TRASH_SUPPORTED: bool = cfg!(all(
    feature = "trash-support",
    not(any(target_os = "android", target_os = "ios"))
));

#[derive(Clone)]
pub struct Rm;

impl Command for Rm {
    fn name(&self) -> &str {
        "rm"
    }

    fn description(&self) -> &str {
        "Remove files and directories."
    }

    fn search_terms(&self) -> Vec<&str> {
        vec!["delete", "remove", "del", "erase"]
    }

    fn signature(&self) -> Signature {
        Signature::build("rm")
            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
            .rest("paths", SyntaxShape::OneOf(vec![SyntaxShape::GlobPattern, SyntaxShape::String]), "The file paths(s) to remove.")
            .switch(
                "trash",
                "Move to the platform's trash instead of permanently deleting. not used on android and ios.",
                Some('t'),
            )
            .switch(
                "permanent",
                "Delete permanently, ignoring the 'always_trash' config option. always enabled on android and ios.",
                Some('p'),
            )
            .switch("recursive", "Delete subdirectories recursively.", Some('r'))
            .switch("force", "Suppress error when no file.", Some('f'))
            .switch("verbose", "Print names of deleted files.", Some('v'))
            .switch("interactive", "Ask user to confirm action.", Some('i'))
            .switch(
                "interactive-once",
                "Ask user to confirm action only once.",
                Some('I'),
            )
            .switch("all", "Remove hidden files if '*' is provided.", Some('a'))
            .category(Category::FileSystem)
    }

    fn run(
        &self,
        engine_state: &EngineState,
        stack: &mut Stack,
        call: &Call,
        _input: PipelineData,
    ) -> Result<PipelineData, ShellError> {
        rm(engine_state, stack, call)
    }

    fn examples(&self) -> Vec<Example<'_>> {
        let mut examples = vec![Example {
            description: "Delete, or move a file to the trash (based on the 'always_trash' config option).",
            example: "rm file.txt",
            result: None,
        }];
        if TRASH_SUPPORTED {
            examples.append(&mut vec![
                Example {
                    description: "Move a file to the trash.",
                    example: "rm --trash file.txt",
                    result: None,
                },
                Example {
                    description:
                        "Delete a file permanently, even if the 'always_trash' config option is true.",
                    example: "rm --permanent file.txt",
                    result: None,
                },
            ]);
        }
        examples.push(Example {
            description: "Delete a file, ignoring 'file not found' errors.",
            example: "rm --force file.txt",
            result: None,
        });
        examples.push(Example {
            description: "Delete all 0KB files in the current directory.",
            example: "ls | where size == 0KB and type == file | each { rm $in.name } | null",
            result: None,
        });
        examples
    }
}

fn rm(
    engine_state: &EngineState,
    stack: &mut Stack,
    call: &Call,
) -> Result<PipelineData, ShellError> {
    let trash = call.has_flag(engine_state, stack, "trash")?;
    let permanent = call.has_flag(engine_state, stack, "permanent")?;
    let recursive = call.has_flag(engine_state, stack, "recursive")?;
    let force = call.has_flag(engine_state, stack, "force")?;
    let verbose = call.has_flag(engine_state, stack, "verbose")?;
    let interactive = call.has_flag(engine_state, stack, "interactive")?;
    let interactive_once = call.has_flag(engine_state, stack, "interactive-once")? && !interactive;
    let all = call.has_flag(engine_state, stack, "all")?;
    let mut paths = call.rest::<Spanned<NuGlob>>(engine_state, stack, 0)?;

    if paths.is_empty() {
        return Err(ShellError::MissingParameter {
            param_name: "requires file paths".to_string(),
            span: call.head,
        });
    }

    let mut unique_argument_check = None;

    let currentdir_path = engine_state.cwd(Some(stack))?.into_std_path_buf();

    let home: Option<String> = nu_path::home_dir().map(|path| {
        {
            if path.exists() {
                nu_path::absolute_with(&path, &currentdir_path).unwrap_or(path.into())
            } else {
                path.into()
            }
        }
        .to_string_lossy()
        .into()
    });

    for (idx, path) in paths.clone().into_iter().enumerate() {
        if let Some(ref home) = home
            && expand_path_with(path.item.as_ref(), &currentdir_path, path.item.is_expand())
                .to_string_lossy()
                .as_ref()
                == home.as_str()
        {
            unique_argument_check = Some(path.span);
        }
        let corrected_path = Spanned {
            item: match path.item {
                NuGlob::DoNotExpand(s) => {
                    NuGlob::DoNotExpand(nu_utils::strip_ansi_string_unlikely(s))
                }
                NuGlob::Expand(s) => NuGlob::Expand(nu_utils::strip_ansi_string_unlikely(s)),
            },
            span: path.span,
        };
        let _ = std::mem::replace(&mut paths[idx], corrected_path);
    }

    let span = call.head;
    let rm_always_trash = stack.get_config(engine_state).rm.always_trash;

    if !TRASH_SUPPORTED {
        if rm_always_trash {
            return Err(ShellError::Generic(GenericError::new(
                "Cannot execute `rm`; the current configuration specifies \
                    `always_trash = true`, but the current nu executable was not \
                    built with feature `trash_support`.",
                "trash required to be true but not supported",
                span,
            )));
        } else if trash {
            return Err(ShellError::Generic(GenericError::new(
                "Cannot execute `rm` with option `--trash`; feature `trash-support` not enabled or on an unsupported platform",
                "this option is only available if nu is built with the `trash-support` feature and the platform supports trash",
                span,
            )));
        }
    }

    if paths.is_empty() {
        return Err(ShellError::Generic(GenericError::new(
            "rm requires target paths",
            "needs parameter",
            span,
        )));
    }

    if unique_argument_check.is_some() && !(interactive_once || interactive) {
        return Err(ShellError::Generic(GenericError::new(
            "You are trying to remove your home dir",
            "If you really want to remove your home dir, please use -I or -i",
            unique_argument_check.unwrap_or(call.head),
        )));
    }

    let targets_span = Span::new(
        paths
            .iter()
            .map(|x| x.span.start)
            .min()
            .expect("targets were empty"),
        paths
            .iter()
            .map(|x| x.span.end)
            .max()
            .expect("targets were empty"),
    );

    let (mut target_exists, mut empty_span) = (false, call.head);
    let mut all_targets: HashMap<PathBuf, Span> = HashMap::new();

    let glob_options = if all {
        None
    } else {
        let glob_options = MatchOptions {
            require_literal_leading_dot: true,
            ..Default::default()
        };

        Some(glob_options)
    };

    for target in paths {
        let path = expand_path_with(
            target.item.as_ref(),
            &currentdir_path,
            target.item.is_expand(),
        );

        // `rm link/` where `link` is a symlink to a directory
        // should error with "is a directory" rather than removing the underlying directory.
        // A trailing slash forces dereferencing the symlink, which rm should not do.
        let raw = target.item.as_ref();
        if raw.ends_with('/') || raw.ends_with(std::path::MAIN_SEPARATOR) {
            let without_sep = raw
                .trim_end_matches('/')
                .trim_end_matches(std::path::MAIN_SEPARATOR);
            let symlink_check =
                expand_path_with(without_sep, &currentdir_path, target.item.is_expand());
            if symlink_check
                .symlink_metadata()
                .map(|m| m.file_type().is_symlink())
                .unwrap_or(false)
            {
                return Err(ShellError::Generic(
                    GenericError::new(
                        format!("Cannot remove `{}`: is a directory", raw),
                        "is a directory",
                        target.span,
                    )
                    .with_help(format!(
                        "use `rm {}` without the trailing slash to remove the symlink itself",
                        without_sep
                    )),
                ));
            }
        }

        if currentdir_path.to_string_lossy() == path.to_string_lossy()
            || currentdir_path.starts_with(format!("{}{}", target.item, std::path::MAIN_SEPARATOR))
        {
            return Err(ShellError::Generic(GenericError::new(
                "Cannot remove any parent directory",
                "cannot remove any parent directory",
                target.span,
            )));
        }

        match nu_engine::glob_from(
            &target,
            &currentdir_path,
            call.head,
            glob_options,
            engine_state.signals().clone(),
        ) {
            Ok(files) => {
                for file in files.1 {
                    match file {
                        Ok(f) => {
                            if !target_exists {
                                target_exists = true;
                            }

                            // It is not appropriate to try and remove the
                            // current directory or its parent when using
                            // glob patterns.
                            let name = f.display().to_string();
                            if name.ends_with("/.") || name.ends_with("/..") {
                                continue;
                            }

                            all_targets
                                .entry(nu_path::expand_path_with(
                                    f,
                                    &currentdir_path,
                                    target.item.is_expand(),
                                ))
                                .or_insert_with(|| target.span);
                        }
                        Err(e) => {
                            return Err(ShellError::Generic(GenericError::new(
                                format!("Could not remove {:}", path.to_string_lossy()),
                                e.to_string(),
                                target.span,
                            )));
                        }
                    }
                }

                // Target doesn't exists
                if !target_exists && empty_span.eq(&call.head) {
                    empty_span = target.span;
                }
            }
            Err(e) => {
                // glob_from may canonicalize path and return an error when a directory is not found
                // nushell should suppress the error if `--force` is used.
                if !(force
                    && matches!(
                        e,
                        ShellError::Io(IoError {
                            kind: shell_error::io::ErrorKind::Std(std::io::ErrorKind::NotFound, ..),
                            ..
                        })
                    ))
                {
                    return Err(e);
                }
            }
        };
    }

    if all_targets.is_empty() && !force {
        return Err(ShellError::Generic(GenericError::new(
            "File(s) not found",
            "File(s) not found",
            targets_span,
        )));
    }

    if interactive_once {
        let (interaction, confirmed) = try_interaction(
            interactive_once,
            format!("rm: remove {} files? ", all_targets.len()),
        );
        if let Err(e) = interaction {
            return Err(ShellError::Generic(GenericError::new_internal(
                format!("Error during interaction: {e:}"),
                "could not move",
            )));
        } else if !confirmed {
            return Ok(PipelineData::empty());
        }
    }

    let iter = all_targets.into_iter().map(move |(f, span)| {
        let is_empty = || match f.read_dir() {
            Ok(mut p) => p.next().is_none(),
            Err(_) => false,
        };

        if let Ok(metadata) = f.symlink_metadata() {
            #[cfg(unix)]
            let is_socket = metadata.file_type().is_socket();
            #[cfg(unix)]
            let is_fifo = metadata.file_type().is_fifo();

            #[cfg(not(unix))]
            let is_socket = false;
            #[cfg(not(unix))]
            let is_fifo = false;

            if metadata.is_file()
                || metadata.file_type().is_symlink()
                || recursive
                || is_socket
                || is_fifo
                || is_empty()
            {
                let (interaction, confirmed) = try_interaction(
                    interactive,
                    format!("rm: remove '{}'? ", f.to_string_lossy()),
                );

                let result = if let Err(e) = interaction {
                    Err(Error::other(&*e.to_string()))
                } else if interactive && !confirmed {
                    Ok(())
                } else if TRASH_SUPPORTED && (trash || (rm_always_trash && !permanent)) {
                    #[cfg(all(
                        feature = "trash-support",
                        not(any(target_os = "android", target_os = "ios"))
                    ))]
                    {
                        trash::delete(&f).map_err(|e: trash::Error| {
                            Error::other(format!("{e:?}\nTry '--permanent' flag"))
                        })
                    }

                    // Should not be reachable since we error earlier if
                    // these options are given on an unsupported platform
                    #[cfg(any(
                        not(feature = "trash-support"),
                        target_os = "android",
                        target_os = "ios"
                    ))]
                    {
                        unreachable!()
                    }
                } else if metadata.is_symlink() {
                    // In Windows, symlink pointing to a directory can be removed using
                    // std::fs::remove_dir instead of std::fs::remove_file.
                    #[cfg(windows)]
                    {
                        use std::os::windows::fs::FileTypeExt;
                        if metadata.file_type().is_symlink_dir() {
                            std::fs::remove_dir(&f)
                        } else {
                            std::fs::remove_file(&f)
                        }
                    }

                    #[cfg(not(windows))]
                    std::fs::remove_file(&f)
                } else if metadata.is_file() || is_socket || is_fifo {
                    std::fs::remove_file(&f)
                } else {
                    std::fs::remove_dir_all(&f)
                };

                if let Err(e) = result {
                    let original_error = e.to_string();
                    Err(ShellError::Io(IoError::new_with_additional_context(
                        e,
                        span,
                        f,
                        original_error,
                    )))
                } else if verbose {
                    let msg = if interactive && !confirmed {
                        "not deleted"
                    } else {
                        "deleted"
                    };
                    Ok(Some(format!("{} {:}", msg, f.to_string_lossy())))
                } else {
                    Ok(None)
                }
            } else {
                let error = format!("Cannot remove {:}. try --recursive", f.to_string_lossy());
                Err(ShellError::Generic(GenericError::new(
                    error,
                    "cannot remove non-empty directory",
                    span,
                )))
            }
        } else {
            let error = format!("no such file or directory: {:}", f.to_string_lossy());
            Err(ShellError::Generic(GenericError::new(
                error,
                "no such file or directory",
                span,
            )))
        }
    });

    let mut cmd_result = Ok(PipelineData::empty());
    for result in iter {
        engine_state.signals().check(&call.head)?;
        match result {
            Ok(None) => {}
            Ok(Some(msg)) => eprintln!("{msg}"),
            Err(err) => {
                if !(force
                    && matches!(
                        err,
                        ShellError::Io(IoError {
                            kind: shell_error::io::ErrorKind::Std(std::io::ErrorKind::NotFound, ..),
                            ..
                        })
                    ))
                {
                    if cmd_result.is_ok() {
                        cmd_result = Err(err);
                    } else {
                        report_shell_error(Some(stack), engine_state, &err)
                    }
                }
            }
        }
    }

    cmd_result
}