Move to ignore for ignoring files

crates/taplo-cli/Cargo.toml

@@ -25,6 +25,7 @@ codespan-reporting = "0.11.1"
 futures = "0.3"
 glob = "0.3"
 hex = "0.4"
+ignore = "0.4.22"
 itertools = "0.10.3"
 once_cell = "1.4"
 regex = "1.4"

crates/taplo-cli/src/commands/format.rs

@@ -214,7 +214,7 @@ impl<E: Environment> Taplo<E> {
             .ok_or_else(|| anyhow!("could not figure the current working directory"))?;
 
         let files = self
-            .collect_files(&cwd, &config, mem::take(&mut cmd.files).into_iter())
+            .files_iter(&cwd, &config, mem::take(&mut cmd.files).into_iter())
             .await?;
 
         let mut result = Ok(());

crates/taplo-cli/src/commands/lint.rs

@@ -77,7 +77,7 @@ impl<E: Environment> Taplo<E> {
             .ok_or_else(|| anyhow!("could not figure the current working directory"))?;
 
         let files = self
-            .collect_files(&cwd, &config, cmd.files.into_iter())
+            .files_iter(&cwd, &config, cmd.files.into_iter())
             .await?;
 
         let mut result = Ok(());

crates/taplo-cli/src/commands/lsp.rs

@@ -1,6 +1,9 @@
 use taplo_common::environment::{native::NativeEnvironment, Environment};
 
-use crate::{args::{LspCommand, LspCommandIo}, Taplo};
+use crate::{
+    args::{LspCommand, LspCommandIo},
+    Taplo,
+};
 
 impl<E: Environment> Taplo<E> {
     pub async fn execute_lsp(&mut self, cmd: LspCommand) -> Result<(), anyhow::Error> {

crates/taplo-cli/src/lib.rs

@@ -1,6 +1,5 @@
 use anyhow::{anyhow, Context};
 use args::GeneralArgs;
-use itertools::Itertools;
 use std::{
     path::{Path, PathBuf},
     str,
@@ -12,6 +11,8 @@ pub mod args;
 pub mod commands;
 pub mod printing;
 
+pub type EntryIter<'a, F> = std::iter::FilterMap<ignore::Walk, F>;
+
 pub struct Taplo<E: Environment> {
     env: E,
     colors: bool,
@@ -84,17 +85,25 @@ impl<E: Environment> Taplo<E> {
     }
 
     #[tracing::instrument(skip_all, fields(?cwd))]
-    async fn collect_files(
+    async fn files_iter(
         &self,
         cwd: &Path,
         config: &Config,
         arg_patterns: impl Iterator<Item = String>,
-    ) -> Result<Vec<PathBuf>, anyhow::Error> {
+    ) -> Result<
+        EntryIter<'_, Box<dyn FnMut(Result<ignore::DirEntry, ignore::Error>) -> Option<PathBuf>>>,
+        anyhow::Error,
+    > {
+        tracing::trace!("Nomarlizing patterns to absolute ones...");
+
         let mut patterns: Vec<String> = arg_patterns
             .map(|pat| {
                 if !self.env.is_absolute(Path::new(&pat)) {
-                    cwd.join(&pat).normalize().to_string_lossy().into_owned()
+                    let pat = cwd.join(&pat).normalize().to_string_lossy().into_owned();
+                    tracing::debug!("Arg(abs) {} ", &pat);
+                    pat
                 } else {
+                    tracing::debug!("Arg(rel) {} ", &pat);
                     pat
                 }
             })
@@ -111,33 +120,67 @@ impl<E: Environment> Taplo<E> {
             };
         };
 
-        let patterns = patterns
-            .into_iter()
-            .unique()
-            .map(|p| glob::Pattern::new(&p).map(|_| p))
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let files = patterns
-            .into_iter()
-            .map(|pat| self.env.glob_files_normalized(&pat))
-            .collect::<Result<Vec<_>, _>>()
-            .into_iter()
-            .flatten()
-            .flatten()
-            .collect::<Vec<_>>();
-
-        let total = files.len();
+        tracing::trace!("Compiled patterns");
 
-        let files = files
-            .into_iter()
-            .filter(|path| config.is_included(path))
-            .collect::<Vec<_>>();
+        let mut skip_patterns = vec![];
+        let mut keep_patterns = vec![];
 
-        let excluded = total - files.len();
-
-        tracing::info!(total, excluded, "found files");
+        let opts = glob::MatchOptions {
+            case_sensitive: true,
+            ..Default::default()
+        };
 
-        Ok(files)
+        let cwd = cwd.to_path_buf();
+
+        let mut bldr = ignore::WalkBuilder::new(&cwd);
+        bldr.git_ignore(true)
+            .git_exclude(true)
+            .git_global(true)
+            .ignore(true)
+            .hidden(false)
+            .same_file_system(true);
+
+        for skip_pattern in config.exclude.iter().cloned().flatten() {
+            if let Ok(pat) = glob::Pattern::new(&skip_pattern) {
+                tracing::trace!("Compiling pattern: {skip_pattern}");
+                skip_patterns.push(pat.clone());
+                bldr.filter_entry(move |entry| !pat.matches_path_with(entry.path(), opts));
+            }
+        }
+        for keep_pattern in config
+            .include
+            .iter()
+            .cloned()
+            .flatten()
+            .map(|x| x.to_owned())
+            .chain(patterns.into_iter())
+        {
+            if let Ok(pat) = glob::Pattern::new(&keep_pattern) {
+                tracing::trace!("Compiling pattern: {pat}");
+                keep_patterns.push(pat.clone());
+                bldr.filter_entry(move |entry| pat.matches_path_with(entry.path(), opts));
+            }
+        }
+        let walker = bldr.build();
+
+        Ok(walker.filter_map(Box::new(
+            move |entry: Result<ignore::DirEntry, ignore::Error>| -> Option<PathBuf> {
+                let entry = entry.ok()?;
+                debug_assert!(!skip_patterns
+                    .iter()
+                    .any(|pat| pat.matches_path_with(entry.path(), opts.clone())));
+                debug_assert!(keep_patterns
+                    .iter()
+                    .any(|pat| pat.matches_path_with(entry.path(), opts)));
+                if entry.path() == cwd {
+                    None
+                } else {
+                    let p = entry.path().to_path_buf();
+                    tracing::debug!("Path passed filters: {}", p.display());
+                    Some(p)
+                }
+            },
+        )))
     }
 }
 

crates/taplo-lsp/src/world.rs

@@ -246,8 +246,9 @@ impl<E: Environment> WorkspaceState<E> {
             };
 
             if let Some(config_path) = config_path {
-                tracing::info!(path = ?config_path, "using config file");
-                self.taplo_config = toml::from_str(str::from_utf8(&env.read_file(&config_path).await?)?)?;
+                tracing::debug!(path = ?config_path, "using config file");
+                self.taplo_config =
+                    toml::from_str(str::from_utf8(&env.read_file(&config_path).await?)?)?;
             }
         }
 

crates/taplo/src/formatter/mod.rs

@@ -681,7 +681,9 @@
                     entry.value.clear();
 
                     if let Some(c) = value.trailing_comment() {
-                        debug_assert!(entry.comment.is_none() || entry.comment.clone().unwrap() == c);
+                        debug_assert!(
+                            entry.comment.is_none() || entry.comment.clone().unwrap() == c
+                        );
                         entry.comment = Some(c);
                     }
 
@@ -1183,7 +1185,7 @@
 }
 
 trait FormattedItem {
     fn syntax(&self) -> SyntaxElement;
     #[allow(clippy::ptr_arg)]
     fn write_to(&self, formatted: &mut String, options: &Options);
     fn trailing_comment(&self) -> Option<String>;