path: root/src/cli.rs

use std::path::{Path, PathBuf};
use std::time::Duration;

use anyhow::anyhow;
use clap::{
    error::ErrorKind, value_parser, Arg, ArgAction, ArgGroup, ArgMatches, Command, Parser,
    ValueEnum,
};
#[cfg(feature = "completions")]
use clap_complete::Shell;
use normpath::PathExt;

use crate::error::print_error;
use crate::exec::CommandSet;
use crate::filesystem;
#[cfg(unix)]
use crate::filter::OwnerFilter;
use crate::filter::SizeFilter;

#[derive(Parser)]
#[command(
    name = "fd",
    version,
    about = "A program to find entries in your filesystem",
    after_long_help = "Bugs can be reported on GitHub: https://github.com/sharkdp/fd/issues",
    max_term_width = 98,
    args_override_self = true,
    group(ArgGroup::new("execs").args(&["exec", "exec_batch", "list_details"]).conflicts_with_all(&[
            "max_results", "has_results", "count"])),
)]
pub struct Opts {
    /// Search hidden files and directories
    #[arg(
        long,
        short = 'H',
        long_help = "Include hidden directories and files in the search results (default: \
                         hidden files and directories are skipped). Files and directories are \
                         considered to be hidden if their name starts with a `.` sign (dot). \
                         The flag can be overridden with --no-hidden."
    )]
    pub hidden: bool,

    /// Overrides --hidden
    #[arg(long, overrides_with = "hidden", hide = true, action = ArgAction::SetTrue)]
    no_hidden: (),

    /// Do not respect .(git|fd)ignore files
    #[arg(
        long,
        short = 'I',
        long_help = "Show search results from files and directories that would otherwise be \
                         ignored by '.gitignore', '.ignore', '.fdignore', or the global ignore file. \
                         The flag can be overridden with --ignore."
    )]
    pub no_ignore: bool,

    /// Overrides --no-ignore
    #[arg(long, overrides_with = "no_ignore", hide = true, action = ArgAction::SetTrue)]
    ignore: (),

    /// Do not respect .gitignore files
    #[arg(
        long,
        hide_short_help = true,
        long_help = "Show search results from files and directories that would otherwise be \
                         ignored by '.gitignore' files. The flag can be overridden with --ignore-vcs."
    )]
    pub no_ignore_vcs: bool,

    /// Overrides --no-ignore-vcs
    #[arg(long, overrides_with = "no_ignore_vcs", hide = true, action = ArgAction::SetTrue)]
    ignore_vcs: (),

    /// Do not respect .(git|fd)ignore files in parent directories
    #[arg(
        long,
        hide_short_help = true,
        long_help = "Show search results from files and directories that would otherwise be \
                     ignored by '.gitignore', '.ignore', or '.fdignore' files in parent directories."
    )]
    pub no_ignore_parent: bool,

    /// Do not respect the global ignore file
    #[arg(long, hide = true)]
    pub no_global_ignore_file: bool,

    /// Unrestricted search, alias for '--no-ignore --hidden'
    #[arg(long = "unrestricted", short = 'u', overrides_with_all(&["ignore", "no_hidden"]), action(ArgAction::Count), hide_short_help = true,
    long_help = "Perform an unrestricted search, including ignored and hidden files. This is \
                 an alias for '--no-ignore --hidden'."
        )]
    rg_alias_hidden_ignore: u8,

    /// Case-sensitive search (default: smart case)
    #[arg(
        long,
        short = 's',
        overrides_with("ignore_case"),
        long_help = "Perform a case-sensitive search. By default, fd uses case-insensitive \
                     searches, unless the pattern contains an uppercase character (smart \
                     case)."
    )]
    pub case_sensitive: bool,

    /// Case-insensitive search (default: smart case)
    #[arg(
        long,
        short = 'i',
        overrides_with("case_sensitive"),
        long_help = "Perform a case-insensitive search. By default, fd uses case-insensitive \
                     searches, unless the pattern contains an uppercase character (smart \
                     case)."
    )]
    pub ignore_case: bool,

    /// Glob-based search (default: regular expression)
    #[arg(
        long,
        short = 'g',
        conflicts_with("fixed_strings"),
        long_help = "Perform a glob-based search instead of a regular expression search."
    )]
    pub glob: bool,

    /// Regular-expression based search (default)
    #[arg(
        long,
        overrides_with("glob"),
        hide_short_help = true,
        long_help = "Perform a regular-expression based search (default). This can be used to \
                     override --glob."
    )]
    pub regex: bool,

    /// Treat pattern as literal string stead of regex
    #[arg(
        long,
        short = 'F',
        alias = "literal",
        hide_short_help = true,
        long_help = "Treat the pattern as a literal string instead of a regular expression. Note \
                     that this also performs substring comparison. If you want to match on an \
                     exact filename, consider using '--glob'."
    )]
    pub fixed_strings: bool,

    /// Show absolute instead of relative paths
    #[arg(
        long,
        short = 'a',
        long_help = "Shows the full path starting from the root as opposed to relative paths. \
                     The flag can be overridden with --relative-path."
    )]
    pub absolute_path: bool,

    /// Overrides --absolute-path
    #[arg(long, overrides_with = "absolute_path", hide = true, action = ArgAction::SetTrue)]
    relative_path: (),

    /// Use a long listing format with file metadata
    #[arg(
        long,
        short = 'l',
        conflicts_with("absolute_path"),
        long_help = "Use a detailed listing format like 'ls -l'. This is basically an alias \
                     for '--exec-batch ls -l' with some additional 'ls' options. This can be \
                     used to see more metadata, to show symlink targets and to achieve a \
                     deterministic sort order."
    )]
    pub list_details: bool,

    /// Follow symbolic links
    #[arg(
        long,
        short = 'L',
        alias = "dereference",
        long_help = "By default, fd does not descend into symlinked directories. Using this \
                     flag, symbolic links are also traversed. \
                     Flag can be overriden with --no-follow."
    )]
    pub follow: bool,

    /// Overrides --follow
    #[arg(long, overrides_with = "follow", hide = true, action = ArgAction::SetTrue)]
    no_follow: (),

    /// Search full abs. path (default: filename only)
    #[arg(
        long,
        short = 'p',
        long_help = "By default, the search pattern is only matched against the filename (or \
                     directory name). Using this flag, the pattern is matched against the full \
                     (absolute) path. Example:\n  \
                       fd --glob -p '**/.git/config'"
    )]
    pub full_path: bool,

    /// Separate search results by the null character
    #[arg(
        long = "print0",
        short = '0',
        conflicts_with("list_details"),
        hide_short_help = true,
        long_help = "Separate search results by the null character (instead of newlines). \
                     Useful for piping results to 'xargs'."
    )]
    pub null_separator: bool,

    /// Set maximum search depth (default: none)
    #[arg(
        long,
        short = 'd',
        value_name = "depth",
        alias("maxdepth"),
        long_help = "Limit the directory traversal to a given depth. By default, there is no \
                     limit on the search depth."
    )]
    max_depth: Option<usize>,

    /// Only show search results starting at the given depth.
    #[arg(
        long,
        value_name = "depth",
        hide_short_help = true,
        long_help = "Only show search results starting at the given depth. \
                     See also: '--max-depth' and '--exact-depth'"
    )]
    min_depth: Option<usize>,

    /// Only show search results at the exact given depth
    #[arg(long, value_name = "depth", hide_short_help = true, conflicts_with_all(&["max_depth", "min_depth"]),
    long_help = "Only show search results at the exact given depth. This is an alias for \
                 '--min-depth <depth> --max-depth <depth>'.",
        )]
    exact_depth: Option<usize>,

    /// Exclude entries that match the given glob pattern
    #[arg(
        long,
        short = 'E',
        value_name = "pattern",
        long_help = "Exclude files/directories that match the given glob pattern. This \
                         overrides any other ignore logic. Multiple exclude patterns can be \
                         specified.\n\n\
                         Examples:\n  \
                           --exclude '*.pyc'\n  \
                           --exclude node_modules"
    )]
    pub exclude: Vec<String>,

    /// Do not traverse into directories that match the search criteria. If
    /// you want to exclude specific directories, use the '--exclude=…' option.
    #[arg(long, hide_short_help = true, conflicts_with_all(&["size", "exact_depth"]),
        long_help = "Do not traverse into directories that match the search criteria. If \
                     you want to exclude specific directories, use the '--exclude=…' option.",
        )]
    pub prune: bool,

    /// Filter by type: file (f), directory (d), symlink (l),
    /// executable (x), empty (e), socket (s), pipe (p)
    #[arg(
        long = "type",
        short = 't',
        value_name = "filetype",
        hide_possible_values = true,
        value_enum,
        long_help = "Filter the search by type:\n  \
                       'f' or 'file':         regular files\n  \
                       'd' or 'directory':    directories\n  \
                       'l' or 'symlink':      symbolic links\n  \
                       's' or 'socket':       socket\n  \
                       'p' or 'pipe':         named pipe (FIFO)\n\n  \
                       'x' or 'executable':   executables\n  \
                       'e' or 'empty':        empty files or directories\n\n\
                     This option can be specified more than once to include multiple file types. \
                     Searching for '--type file --type symlink' will show both regular files as \
                     well as symlinks. Note that the 'executable' and 'empty' filters work differently: \
                     '--type executable' implies '--type file' by default. And '--type empty' searches \
                     for empty files and directories, unless either '--type file' or '--type directory' \
                     is specified in addition.\n\n\
                     Examples:\n  \
                       - Only search for files:\n      \
                           fd --type file …\n      \
                           fd -tf …\n  \
                       - Find both files and symlinks\n      \
                           fd --type file --type symlink …\n      \
                           fd -tf -tl …\n  \
                       - Find executable files:\n      \
                           fd --type executable\n      \
                           fd -tx\n  \
                       - Find empty files:\n      \
                           fd --type empty --type file\n      \
                           fd -te -tf\n  \
                       - Find empty directories:\n      \
                           fd --type empty --type directory\n      \
                           fd -te -td"
    )]
    pub filetype: Option<Vec<FileType>>,

    /// Filter by file extension
    #[arg(
        long = "extension",
        short = 'e',
        value_name = "ext",
        long_help = "(Additionally) filter search results by their file extension. Multiple \
                     allowable file extensions can be specified.\n\
                     If you want to search for files without extension, \
                     you can use the regex '^[^.]+$' as a normal search pattern."
    )]
    pub extensions: Option<Vec<String>>