Rewrite directory scanner to better handle ignored directories

Author: jm6271

loc/DirectoryScanner.cpp

@@ -12,54 +12,52 @@ namespace fs = std::filesystem;
 std::vector<std::string> DirectoryScanner::Scan(const fs::path& directory, const std::vector<std::string>& extensions,
                                                 const std::vector<std::string>& ignoreDirs) const
 {
-    // Scan a directory and return a list of all the paths to the files with the given extensions
-    std::vector<std::string> file_paths; 
-    
-    if (fs::exists(directory) && fs::is_directory(directory))
-    { 
-        for (const auto& entry : fs::recursive_directory_iterator(directory))
-        { 
-            if (fs::is_regular_file(entry.status())) 
-            { 
-                // Check if the file has one of the extensions
-                bool has_extension = false;
-                for (const auto& extension : extensions) 
-                { 
-                    if (entry.path().extension() == extension) 
-                    { 
-                        has_extension = true;
-                        break;
-                    } 
-                } 
-                if (!has_extension) 
-                    continue;
-                
-                try
-                {
-                    file_paths.push_back(entry.path().string()); 
-                }
-                catch(const std::system_error& e)
-                {
-                    // Sometimes throws this error:
-                    // No mapping for the Unicode character exists in the target multi-byte code page
+    std::vector<std::string> result;
+
+    if (!fs::exists(directory) || !fs::is_directory(directory)) {
+        return result;
+    }
+
+    // Normalize ignore directories into absolute canonical paths
+    std::vector<fs::path> ignorePaths;
+    for (const auto& dir : ignoreDirs) {
+        fs::path p(dir);
+        if (p.is_absolute()) {
+            ignorePaths.push_back(fs::weakly_canonical(p));
+        } else {
+            ignorePaths.push_back(fs::weakly_canonical(directory / p));
+        }
+    }
 
-                    // Ignore the file and print a warning
-                    std::cerr << "Warning: System error thrown while getting a file path. Skipping file.\n";
-                    std::cerr << "Error message: " << e.what() << '\n';
+    fs::recursive_directory_iterator it(directory), end;
+    while (it != end) {
+        const fs::directory_entry& entry = *it;
 
-                    continue;
-                }
-            } 
+        if (entry.is_directory()) {
+            fs::path current = fs::weakly_canonical(entry.path());
+
+            // Skip if inside any ignored directory
+            bool skip = std::any_of(ignorePaths.begin(), ignorePaths.end(),
+                                    [&](const fs::path& ignore) {
+                                        return isSubPath(ignore, current);
+                                    });
+
+            if (skip) {
+                it.disable_recursion_pending(); // skip this whole subtree
+            }
         } 
+        else if (entry.is_regular_file()) {
+            std::string ext = entry.path().extension().string();
+
+            if (std::find(extensions.begin(), extensions.end(), ext) != extensions.end()) {
+                result.push_back(entry.path().string());
+            }
+        }
+
+        ++it;
     }
-    else 
-    { 
-        std::cerr << "Directory does not exist or is not a directory " << directory << std::endl; 
-    } 
-    
-    // Remove files in ignored directories
-    RemoveIgnoredFiles(file_paths, ignoreDirs);
-    return file_paths;
+
+    return result;
 }
 
 std::vector<std::string> DirectoryScanner::FindIgnoredDirectories(const std::filesystem::path &directory, const std::vector<std::string> &ignorePatterns) const
@@ -102,19 +100,20 @@ std::vector<std::string> DirectoryScanner::FindIgnoredDirectories(const std::fil
     return ignoredDirectories;
 }
 
-void DirectoryScanner::RemoveIgnoredFiles(std::vector<std::string> &filePaths, const std::vector<std::string> &ignoreDirs) const
+bool DirectoryScanner::isSubPath(const std::filesystem::path &base, const std::filesystem::path &path) const
 {
-    filePaths.erase(std::remove_if(filePaths.begin(), filePaths.end(),
-                                   [&ignoreDirs](const std::string& filePath)
-                                   {
-                                       for (const auto& ignoreDir : ignoreDirs)
-                                       {
-                                           if (filePath.find(ignoreDir) != std::string::npos)
-                                           {
-                                               return true; // Remove this file
-                                           }
-                                       }
-                                       return false; // Keep this file
-                                   }),
-                    filePaths.end());
+    auto baseAbs = fs::weakly_canonical(base);
+    auto pathAbs = fs::weakly_canonical(path);
+
+    auto baseIt = baseAbs.begin();
+    auto pathIt = pathAbs.begin();
+
+    for (; baseIt != baseAbs.end() && pathIt != pathAbs.end(); ++baseIt, ++pathIt) {
+        if (*baseIt != *pathIt) {
+            return false;
+        }
+    }
+
+    // True if base was fully consumed (base == path, or base is a prefix of path)
+    return baseIt == baseAbs.end();
 }

loc/include/DirectoryScanner.h

@@ -16,5 +16,5 @@ class DirectoryScanner
     std::vector<std::string> FindIgnoredDirectories(const std::filesystem::path& directory, const std::vector<std::string>& ignorePatterns) const;
 
 private:
-    void RemoveIgnoredFiles(std::vector<std::string>& filePaths, const std::vector<std::string>& ignoreDirs) const;
+    bool isSubPath(const std::filesystem::path& base, const std::filesystem::path& path) const;
 };