Fix new file detection in PostCSS plugin (#14829)

We broke this at some point — probably when we tried to optimize
rebuilds in PostCSS by not performing a full auto-source detection scan.

This PR addresses this problem by:
1. Storing a list of found directories
2. Comparing their mod times on every scan
3. If the mod time has changed we scan the directory for new files which
we then store and scan

Author: thecrypticace

CHANGELOG.md

@@ -7,7 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-- Nothing yet!
+### Fixed
+
+- Detect classes in new files when using `@tailwindcss/postcss` ([#14829](https://github.com/tailwindlabs/tailwindcss/pull/14829))
 
 ## [4.0.0-alpha.31] - 2024-10-29
 

crates/oxide/src/lib.rs

@@ -9,6 +9,7 @@ use glob::optimize_patterns;
 use glob_match::glob_match;
 use paths::Path;
 use rayon::prelude::*;
+use scanner::allowed_paths::read_dir;
 use std::fs;
 use std::path::PathBuf;
 use std::sync;
@@ -77,6 +78,9 @@ pub struct Scanner {
     /// All files that we have to scan
     files: Vec<PathBuf>,
 
+    /// All directories, sub-directories, etc… we saw during source detection
+    dirs: Vec<PathBuf>,
+
     /// All generated globs
     globs: Vec<GlobEntry>,
 
@@ -98,7 +102,7 @@ impl Scanner {
     pub fn scan(&mut self) -> Vec<String> {
         init_tracing();
         self.prepare();
-
+        self.check_for_new_files();
         self.compute_candidates();
 
         let mut candidates: Vec<String> = self.candidates.clone().into_iter().collect();
@@ -213,6 +217,62 @@ impl Scanner {
         self.ready = true;
     }
 
+    #[tracing::instrument(skip_all)]
+    fn check_for_new_files(&mut self) {
+        let mut modified_dirs: Vec<PathBuf> = vec![];
+
+        // Check all directories to see if they were modified
+        for path in &self.dirs {
+            let current_time = fs::metadata(path)
+                .and_then(|m| m.modified())
+                .unwrap_or(SystemTime::now());
+
+            let previous_time = self.mtimes.insert(path.clone(), current_time);
+
+            let should_scan = match previous_time {
+                // Time has changed, so we need to re-scan the file
+                Some(prev) if prev != current_time => true,
+
+                // File was in the cache, no need to re-scan
+                Some(_) => false,
+
+                // File didn't exist before, so we need to scan it
+                None => true,
+            };
+
+            if should_scan {
+                modified_dirs.push(path.clone());
+            }
+        }
+
+        // Scan all modified directories for their immediate files
+        let mut known = FxHashSet::from_iter(self.files.iter().chain(self.dirs.iter()).cloned());
+
+        while !modified_dirs.is_empty() {
+            let new_entries = modified_dirs
+                .iter()
+                .flat_map(|dir| read_dir(dir, Some(1)))
+                .map(|entry| entry.path().to_owned())
+                .filter(|path| !known.contains(path))
+                .collect::<Vec<_>>();
+
+            modified_dirs.clear();
+
+            for path in new_entries {
+                if path.is_file() {
+                    known.insert(path.clone());
+                    self.files.push(path);
+                } else if path.is_dir() {
+                    known.insert(path.clone());
+                    self.dirs.push(path.clone());
+
+                    // Recursively scan the new directory for files
+                    modified_dirs.push(path);
+                }
+            }
+        }
+    }
+
     #[tracing::instrument(skip_all)]
     fn scan_sources(&mut self) {
         let Some(sources) = &self.sources else {
@@ -282,9 +342,10 @@ impl Scanner {
             // Detect all files/folders in the directory
             let detect_sources = DetectSources::new(path);
 
-            let (files, globs) = detect_sources.detect();
+            let (files, globs, dirs) = detect_sources.detect();
             self.files.extend(files);
             self.globs.extend(globs);
+            self.dirs.extend(dirs);
         }
 
         // Turn `Vec<&GlobEntry>` in `Vec<GlobEntry>`

crates/oxide/src/scanner/allowed_paths.rs

@@ -27,9 +27,25 @@ static IGNORED_CONTENT_DIRS: sync::LazyLock<Vec<&'static str>> =
 
 #[tracing::instrument(skip(root))]
 pub fn resolve_allowed_paths(root: &Path) -> impl Iterator<Item = DirEntry> {
+    // Read the directory recursively with no depth limit
+    read_dir(root, None)
+}
+
+#[tracing::instrument(skip(root))]
+pub fn resolve_paths(root: &Path) -> impl Iterator<Item = DirEntry> {
     WalkBuilder::new(root)
         .hidden(false)
         .require_git(false)
+        .build()
+        .filter_map(Result::ok)
+}
+
+#[tracing::instrument(skip(root))]
+pub fn read_dir(root: &Path, depth: Option<usize>) -> impl Iterator<Item = DirEntry> {
+    WalkBuilder::new(root)
+        .hidden(false)
+        .require_git(false)
+        .max_depth(depth)
         .filter_entry(move |entry| match entry.file_type() {
             Some(file_type) if file_type.is_dir() => match entry.file_name().to_str() {
                 Some(dir) => !IGNORED_CONTENT_DIRS.contains(&dir),
@@ -44,15 +60,6 @@ pub fn resolve_allowed_paths(root: &Path) -> impl Iterator<Item = DirEntry> {
         .filter_map(Result::ok)
 }
 
-#[tracing::instrument(skip(root))]
-pub fn resolve_paths(root: &Path) -> impl Iterator<Item = DirEntry> {
-    WalkBuilder::new(root)
-        .hidden(false)
-        .require_git(false)
-        .build()
-        .filter_map(Result::ok)
-}
-
 pub fn is_allowed_content_path(path: &Path) -> bool {
     // Skip known ignored files
     if path

crates/oxide/src/scanner/detect_sources.rs

@@ -27,11 +27,11 @@ impl DetectSources {
         Self { base }
     }
 
-    pub fn detect(&self) -> (Vec<PathBuf>, Vec<GlobEntry>) {
+    pub fn detect(&self) -> (Vec<PathBuf>, Vec<GlobEntry>, Vec<PathBuf>) {
         let (files, dirs) = self.resolve_files();
         let globs = self.resolve_globs(&dirs);
 
-        (files, globs)
+        (files, globs, dirs)
     }
 
     fn resolve_files(&self) -> (Vec<PathBuf>, Vec<PathBuf>) {