feat(ignore): Typos-specific ignores

THis is to help with cases like a monorepo with vendored dependencies.
A user might want to search (`.ignore`) them but not hold the code to
the same standards as first-party code.

Fixes #134

src/config.rs

@@ -16,6 +16,16 @@ pub trait WalkSource {
         None
     }
 
+    /// The root for `ignore_patterns`
+    fn ignore_root(&self) -> Option<&std::path::Path> {
+        None
+    }
+
+    /// Ignore the specified patterns (gitignore syntax)
+    fn ignore_patterns(&self) -> Option<&[String]> {
+        None
+    }
+
     /// Skip hidden files and directories.
     fn ignore_hidden(&self) -> Option<bool> {
         None
@@ -101,7 +111,9 @@ impl Config {
         let mut file = std::fs::File::open(path)?;
         let mut s = String::new();
         file.read_to_string(&mut s)?;
-        Self::from_toml(&s)
+        let mut c = Self::from_toml(&s)?;
+        c.files.ignore_root = path.parent().map(|p| p.to_owned());
+        Ok(c)
     }
 
     pub fn from_toml(data: &str) -> Result<Self, anyhow::Error> {
@@ -138,6 +150,9 @@ impl ConfigSource for Config {
 #[serde(rename_all = "kebab-case")]
 pub struct Walk {
     pub binary: Option<bool>,
+    #[serde(skip)]
+    pub ignore_root: Option<std::path::PathBuf>,
+    pub ignore_patterns: Option<Vec<String>>,
     pub ignore_hidden: Option<bool>,
     pub ignore_files: Option<bool>,
     pub ignore_dot: Option<bool>,
@@ -151,6 +166,10 @@ impl Walk {
         if let Some(source) = source.binary() {
             self.binary = Some(source);
         }
+        if let (Some(root), Some(source)) = (source.ignore_root(), source.ignore_patterns()) {
+            self.ignore_root = Some(root.to_owned());
+            self.ignore_patterns = Some(source.to_owned());
+        }
         if let Some(source) = source.ignore_hidden() {
             self.ignore_hidden = Some(source);
         }
@@ -180,6 +199,14 @@ impl Walk {
         self.binary.unwrap_or(false)
     }
 
+    pub fn ignore_root(&self) -> Option<&std::path::Path> {
+        self.ignore_root.as_deref()
+    }
+
+    pub fn ignore_patterns(&self) -> Option<&[String]> {
+        self.ignore_patterns.as_deref()
+    }
+
     pub fn ignore_hidden(&self) -> bool {
         self.ignore_hidden.unwrap_or(true)
     }
@@ -215,6 +242,14 @@ impl WalkSource for Walk {
         self.binary
     }
 
+    fn ignore_root(&self) -> Option<&std::path::Path> {
+        self.ignore_root.as_deref()
+    }
+
+    fn ignore_patterns(&self) -> Option<&[String]> {
+        self.ignore_patterns.as_deref()
+    }
+
     fn ignore_hidden(&self) -> Option<bool> {
         self.ignore_hidden
     }

src/main.rs

@@ -75,6 +75,16 @@ fn run() -> Result<i32, anyhow::Error> {
             .git_ignore(config.files.ignore_vcs())
             .git_exclude(config.files.ignore_vcs())
             .parents(config.files.ignore_parent());
+        if let (Some(root), Some(patterns)) =
+            (config.files.ignore_root(), config.files.ignore_patterns())
+        {
+            let mut overrides = ignore::overrides::OverrideBuilder::new(root);
+            for pattern in patterns {
+                overrides.add(pattern)?;
+            }
+            let overrides = overrides.build()?;
+            walk.overrides(overrides);
+        }
 
         let mut reporter = args.format.reporter();
         let replace_reporter = replace::Replace::new(reporter);