Allow exclude/ignore by absolute path

contrib/completion/_fd

@@ -110,6 +110,7 @@ _fd() {
  '*'{-t+,--type=}"[filter search by type]:type:(($fd_types))"
  '*'{-e+,--extension=}'[filter search by file extension]:extension'
  '*'{-E+,--exclude=}'[exclude files/directories that match the given glob pattern]:glob pattern'
+ '*--exclude-absolute=[exclude files/directories whose absolute path match the given glob pattern]:glob pattern'
  '*'{-S+,--size=}'[limit search by file size]:size limit:->size'
  '(-o --owner)'{-o+,--owner=}'[filter by owning user and/or group]:owner and/or group:->owner'
 

src/cli.rs

@@ -46,7 +46,7 @@ pub struct Opts {
  no_hidden: (),
 
  /// Show search results from files and directories that would otherwise be
- /// ignored by '.gitignore', '.ignore', '.fdignore', or the global ignore file.
+ /// ignored by '.gitignore', '.ignore', '.fdignore', or the global ignore files.
  /// The flag can be overridden with --ignore.
  #[arg(
  long,
@@ -106,7 +106,7 @@ pub struct Opts {
  )]
  pub no_ignore_parent: bool,
 
- /// Do not respect the global ignore file
+ /// Do not respect the global ignore files
  #[arg(long, hide = true)]
  pub no_global_ignore_file: bool,
 
@@ -300,6 +300,21 @@ pub struct Opts {
  )]
  pub exclude: Vec<String>,
 
+ /// Exclude files/directories whose absolute path match the given glob pattern.
+ /// This filter is applied on top of all other ignore logic. Multiple exclude patterns
+ /// can be specified.
+ ///
+ /// Note that using this filter causes fd to perform an extra canonicalization
+ /// for every path traversed, which incurs a non-trivial performance penalty.
+ /// Use at your own discretion.
+ #[arg(
+ long,
+ value_name = "pattern",
+ help = "Exclude entries whose absolute path match the given glob pattern",
+ long_help
+ )]
+ pub exclude_absolute: 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"]),

src/config.rs

@@ -1,5 +1,6 @@
 use std::{path::PathBuf, sync::Arc, time::Duration};
 
+use globset::GlobMatcher;
 use lscolors::LsColors;
 use regex::bytes::RegexSet;
 
@@ -95,6 +96,9 @@ pub struct Config {
  /// A list of glob patterns that should be excluded from the search.
  pub exclude_patterns: Vec<String>,
 
+ /// A list of glob matchers that should exclude matched entries by their absolute paths.
+ pub exclude_absolute_matchers: Vec<GlobMatcher>,
+
  /// A list of custom ignore files.
  pub ignore_files: Vec<PathBuf>,
 
@@ -130,3 +134,19 @@ impl Config {
  self.command.is_none()
  }
 }
+
+/// Get the platform-specific config directory for fd.
+pub fn get_fd_config_dir() -> Option<PathBuf> {
+ #[cfg(target_os = "macos")]
+ let mut dir = std::env::var_os("XDG_CONFIG_HOME")
+ .map(PathBuf::from)
+ .filter(|p| p.is_absolute())
+ .or_else(|| dirs_next::home_dir().map(|d| d.join(".config")))?;
+
+ #[cfg(not(target_os = "macos"))]
+ let mut dir = dirs_next::config_dir()?;
+
+ dir.push("fd");
+
+ Some(dir)
+}

src/main.rs

@@ -19,12 +19,13 @@ use std::time;
 use anyhow::{anyhow, bail, Context, Result};
 use atty::Stream;
 use clap::{CommandFactory, Parser};
-use globset::GlobBuilder;
+use globset::{Glob, GlobBuilder, GlobMatcher};
 use lscolors::LsColors;
 use regex::bytes::{Regex, RegexBuilder, RegexSetBuilder};
 
 use crate::cli::{ColorWhen, Opts};
-use crate::config::Config;
+use crate::config::{get_fd_config_dir, Config};
+use crate::error::print_error;
 use crate::exec::CommandSet;
 use crate::exit_codes::ExitCode;
 use crate::filetypes::FileTypes;
@@ -233,6 +234,28 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
  let command = extract_command(&mut opts, colored_output)?;
  let has_command = command.is_some();
 
+ let read_global_ignore =
+ !(opts.no_ignore || opts.rg_alias_ignore() || opts.no_global_ignore_file);
+ let exclude_absolute_matchers = {
+ let mut matchers = vec![];
+
+ // absolute excludes from CLI
+ for glob_str in opts.exclude_absolute.iter() {
+ // invalid globs from CLI are hard errors
+ let m = Glob::new(glob_str)?.compile_matcher();
+ matchers.push(m);
+ }
+ // absolute excludes from global `ignore-absolute` file
+ if read_global_ignore {
+ match read_and_build_global_exclude_absolute_matchers() {
+ Ok(mut v) => matchers.append(&mut v),
+ Err(err) => print_error(format!("Cannot read global ignore-absolute file. {err}.")),
+ }
+ }
+
+ matchers
+ };
+
  Ok(Config {
  case_sensitive,
  search_full_path: opts.full_path,
@@ -241,9 +264,7 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
  read_vcsignore: !(opts.no_ignore || opts.rg_alias_ignore() || opts.no_ignore_vcs),
  require_git_to_read_vcsignore: !opts.no_require_git,
  read_parent_ignore: !opts.no_ignore_parent,
- read_global_ignore: !(opts.no_ignore
- || opts.rg_alias_ignore()
- || opts.no_global_ignore_file),
+ read_global_ignore,
  follow_links: opts.follow,
  one_file_system: opts.one_file_system,
  null_separator: opts.null_separator,
@@ -297,6 +318,7 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
  command: command.map(Arc::new),
  batch_size: opts.batch_size,
  exclude_patterns: opts.exclude.iter().map(|p| String::from("!") + p).collect(),
+ exclude_absolute_matchers,
  ignore_files: std::mem::take(&mut opts.ignore_file),
  size_constraints: size_limits,
  time_constraints,
@@ -468,3 +490,44 @@ fn build_regex(pattern_regex: String, config: &Config) -> Result<regex::bytes::R
  )
  })
 }
+
+fn read_and_build_global_exclude_absolute_matchers() -> Result<Vec<GlobMatcher>> {
+ let file_content = match get_fd_config_dir()
+ .map(|p| p.join("ignore-absolute"))
+ .filter(|p| p.is_file())
+ {
+ Some(path) => std::fs::read_to_string(path)?,
+ // not an error if the file doesn't exist
+ None => return Ok(vec![]),
+ };
+
+ let matchers = file_content
+ .lines()
+ // trim trailing spaces, unless escaped with backslash (`\`)
+ .map(|raw| {
+ let naive_trimmed = raw.trim_end_matches(' ');
+ if raw.len() == naive_trimmed.len() {
+ raw
+ } else if naive_trimmed.ends_with('\\') {
+ &raw[..naive_trimmed.len() + 1]
+ } else {
+ naive_trimmed
+ }
+ })
+ // skip empty lines and comments
+ .filter(|line| !line.is_empty() && !line.starts_with('#'))
+ // build matchers
+ .filter_map(|line| match Glob::new(line) {
+ Ok(glob) => Some(glob.compile_matcher()),
+ // invalid globs from config file are warnings
+ Err(err) => {
+ print_error(format!(
+ "Malformed pattern in global ignore-absolute file. {err}."
+ ));
+ None
+ }
+ })
+ .collect();
+
+ Ok(matchers)
+}

src/walk.rs

@@ -14,6 +14,7 @@ use ignore::overrides::OverrideBuilder;
 use ignore::{self, WalkBuilder};
 use regex::bytes::Regex;
 
+use crate::config::get_fd_config_dir;
 use crate::config::Config;
 use crate::dir_entry::DirEntry;
 use crate::error::print_error;
@@ -89,17 +90,8 @@ pub fn scan(paths: &[PathBuf], patterns: Arc<Vec<Regex>>, config: Arc<Config>) -
  }
 
  if config.read_global_ignore {
- #[cfg(target_os = "macos")]
- let config_dir_op = std::env::var_os("XDG_CONFIG_HOME")
- .map(PathBuf::from)
- .filter(|p| p.is_absolute())
- .or_else(|| dirs_next::home_dir().map(|d| d.join(".config")));
-
- #[cfg(not(target_os = "macos"))]
- let config_dir_op = dirs_next::config_dir();
-
- if let Some(global_ignore_file) = config_dir_op
- .map(|p| p.join("fd").join("ignore"))
+ if let Some(global_ignore_file) = get_fd_config_dir()
+ .map(|p| p.join("ignore"))
  .filter(|p| p.is_file())
  {
  let result = walker.add_ignore(global_ignore_file);
@@ -534,6 +526,36 @@ fn spawn_senders(
  }
  }
 
+ // Exclude by absolute path
+ // `ignore` crate does not intend to support this, so it's implemented here independently
+ // see https://github.com/BurntSushi/ripgrep/issues/2366
+ // This is done last because canonicalisation has non-trivial cost
+ if !config.exclude_absolute_matchers.is_empty() {
+ match entry_path.canonicalize() {
+ Ok(path) => {
+ if config
+ .exclude_absolute_matchers
+ .iter()
+ .any(|glob| glob.is_match(&path))
+ {
+ // Ideally we want to return `WalkState::Skip` to emulate gitignore's
+ // behavior of skipping any matched directory entirely
+ // Unfortunately this will make the search behaviour inconsistent
+ // because this filter happens outside of the directory walker
+ //
+ // E.g. Given directory structure `/foo/bar/` and CWD `/`:
+ // - `fd --exclude-absolute '/foo'` will return nothing
+ // - `fd --exclude-absolute '/foo' bar` will return '/foo/bar'
+ // Obviously this makes no sense
+ return ignore::WalkState::Continue;
+ }
+ }
+ Err(err) => {
+ print_error(format!("Cannot canonicalize {entry_path:?}. {err}."));
+ }
+ }
+ }
+
  if config.is_printing() {
  if let Some(ls_colors) = &config.ls_colors {
  // Compute colors in parallel