Fix normalization of exclude option and root directory edge case in gitignore handling

Author: RemiKalbe

CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.3] - 2024-09-19
+
+### Fixed
+
+- Fixed the normalization of the `exclude` option when the path is `.` or `./`.
+- Fixed the edge case where the root directory is ignored by the `.gitignore` when the path is `.` or `./` and the `gitignore` has `.*` as an ignore pattern.
+
 ## [0.2.2] - 2024-09-18
 
 ### Added

src/codebase/mod.rs

@@ -138,8 +138,13 @@ impl CodebaseBuilder {
                         Logger::trace("No gitignore impacting current branch");
                     }
 
+                    // Edge case: gitignore has ".*" pattern (ignoring all dotfiles)
+                    // and the root directory is '.', do not skip the root directory
+                    let is_entry_root = entry.path() == from;
                     // Is the entry excluded by the gitignore?
-                    if maybe_gitignore.map_or(false, |gitignore| gitignore.is_excluded(&path)) {
+                    if maybe_gitignore.map_or(false, |gitignore| gitignore.is_excluded(&path))
+                        && !is_entry_root
+                    {
                         Logger::debug("Entry is excluded by the gitignore");
 
                         // If it's a directory, skip it entirely
@@ -576,4 +581,30 @@ mod tests {
             .iter()
             .any(|item| item.path.file_name().unwrap() == "config.log"));
     }
+
+    // Edge cases
+
+    fn create_dot_root_edge_case_structure(root: &Path) {
+        // Root level
+        create_file(&root.join(".gitignore"), ".*");
+        create_file(&root.join("root.txt"), "root content");
+    }
+
+    #[tokio::test]
+    async fn test_dot_root_edge_case() {
+        ensure_logger();
+        let temp_dir = TempDir::new().unwrap();
+        create_dot_root_edge_case_structure(temp_dir.path());
+
+        let codebase = CodebaseBuilder::new()
+            .consider_gitignores(true)
+            .build(temp_dir.path().to_path_buf())
+            .await
+            .unwrap();
+
+        let root_leaves: Vec<_> = codebase.tree.collect_local_leaves();
+        assert!(root_leaves
+            .iter()
+            .any(|item| item.path.file_name().unwrap() == "root.txt"));
+    }
 }

src/main.rs

@@ -8,6 +8,7 @@ pub mod gitignore;
 pub mod logger;
 pub mod os;
 pub mod tree;
+pub mod utils;
 
 use codebase::CodebaseBuilder;
 use error::{CunwError, Result};
@@ -17,6 +18,7 @@ use logger::Logger;
 /// why we should consider these files but if you want
 /// to include them you can use `--dangerously-allow-dot-git-traversal` flag.
 const GIT_RELATED_IGNORE_PATTERNS: [&str; 2] = ["**/.git", "./**/.git"];
+const BASE_PATH_EDGE_CASES: [&str; 2] = [".", "./"];
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -33,34 +35,25 @@ async fn main() -> Result<()> {
     // Build the excluded paths
     let mut excluded_paths = GlobSetBuilder::new();
     if let Some(exclude) = args.exclude {
-        // We normalize the path so that the glob pattern
-        // begins with the base path.
-        // We also ensure that we normalize only if needed.
-        let base = args.path.clone();
-        let base = base.to_str().unwrap();
-        let base = {
-            if base.ends_with('/') {
-                base.to_string()
-            } else {
-                format!("{}/", base)
-            }
-        };
         for glob in exclude {
-            let excluded_paths_with_base = {
+            // Edge case, if the path starts with '.' or './'
+            let excluded_path = {
                 let original_glob = glob.glob();
-                if !original_glob.starts_with(&base) {
-                    if original_glob.starts_with('/') {
-                        let glob = original_glob.strip_prefix('/').unwrap().to_string();
-                        format!("{}{}", base, glob)
+                if let Some(path_prefix) =
+                    utils::start_with_one_of(&args.path.to_str().unwrap(), &BASE_PATH_EDGE_CASES)
+                {
+                    if let Some(glob_prefix) =
+                        utils::start_with_one_of(&original_glob, &BASE_PATH_EDGE_CASES)
+                    {
+                        original_glob.replacen(glob_prefix, path_prefix, 1)
                     } else {
-                        let glob = original_glob.to_string();
-                        format!("{}{}", base, glob)
+                        format!("./{}", original_glob)
                     }
                 } else {
                     original_glob.to_string()
                 }
             };
-            let glob = Glob::new(&excluded_paths_with_base).unwrap();
+            let glob = Glob::new(&excluded_path).unwrap();
             excluded_paths.add(glob);
         }
     }

src/utils.rs

@@ -0,0 +1,57 @@
+/// Checks if the given `snippet` starts with any of the provided `prefixes`.
+///
+/// # Arguments
+///
+/// * `snippet` - A string slice that will be checked.
+/// * `prefixes` - A slice of string slices representing the prefixes to check against.
+///
+/// # Returns
+///
+/// * `Some(prefix)` if the `snippet` starts with any of the `prefixes`, where `prefix` is the
+///  first matching prefix.
+/// * `None` otherwise.
+///
+/// # Examples
+///
+/// ```
+/// let snippet = "hello world";
+/// let prefixes = ["he", "wo"];
+/// assert_eq!(start_with_one_of(snippet, &prefixes), Some("he"));
+/// ```
+pub fn start_with_one_of<'a>(snippet: &str, prefixes: &[&'a str]) -> Option<&'a str> {
+    for prefix in prefixes {
+        if snippet.starts_with(prefix) {
+            return Some(prefix);
+        }
+    }
+    None
+}
+
+/// Checks if the given `snippet` ends with any of the provided `suffixes`.
+///
+/// # Arguments
+///
+/// * `snippet` - A string slice that will be checked.
+/// * `suffixes` - A slice of string slices representing the suffixes to check against.
+///
+/// # Returns
+///
+/// * `Some(suffix)` if the `snippet` ends with any of the `suffixes`, where `suffix` is the
+/// first matching suffix.
+/// * `None` otherwise.
+///
+/// # Examples
+///
+/// ```
+/// let snippet = "hello world";
+/// let suffixes = ["ld", "lo"];
+/// assert_eq!(end_with_one_of(snippet, &suffixes), Some("ld"));
+/// ```
+pub fn end_with_one_of<'a>(snippet: &str, suffixes: &[&'a str]) -> Option<&'a str> {
+    for suffix in suffixes {
+        if snippet.ends_with(suffix) {
+            return Some(suffix);
+        }
+    }
+    None
+}