feat(gitignore): handle ignoring from workdir root (#1150)

Omni already handles the global gitignore on top of the local gitignore,
but when a subdirectory of a workdir is a git repository, the gitignore
ends-up being checked from the most specific git repository, and not
necessarily the one corresponding to the omni workdir.

This fixes that by passing down the workdir root path to be used as
git-base, if in a git workdir.

Closes #1143

Author: xaf

.omni.yaml

@@ -8,6 +8,7 @@ up:
 
 commands:
   create-tag:
+    argparser: true
     desc: Create a new version tag for omni
     run: |
       set -e
@@ -45,6 +46,7 @@ commands:
       echo "Created tag: $new_tag"
 
   website-dev:
+    argparser: true
     desc: |
       Starts a local development server for the website
 
@@ -55,6 +57,7 @@ commands:
       yarn start
 
   cargo-package:
+    argparser: true
     desc: Runs cargo package after overriding the version
     run: |
       # Check if git is dirty
@@ -81,6 +84,7 @@ commands:
       git checkout Cargo.toml
 
   lint:
+    argparser: true
     desc: Runs the linter
     aliases:
       - clippy
@@ -89,18 +93,46 @@ commands:
       cargo clippy --all-features
 
   test:
-    desc: Runs the tests
+    argparser: true
+    desc: Runs all tests
+    syntax:
+      parameters:
+        - name: --unit
+          type: flag
+          desc: Select the unit tests
+        - name: --integration
+          type: flag
+          desc: Select the integration tests
     run: |
       set -e
-      cargo test
-      GENERATE_FIXTURES=false bats tests/
+
+      run_unit=${OMNI_ARG_UNIT_VALUE:-false}
+      run_integration=${OMNI_ARG_INTEGRATION_VALUE:-false}
+
+      if [[ "$run_unit" == "false" && "$run_integration" == "false" ]]; then
+        run_unit=true
+        run_integration=true
+      fi
+
+      if [[ "$run_unit" == "true" ]]; then
+        echo >&2 -e "\033[1;34mRunning unit tests...\033[0m"
+        cargo test
+      fi
+
+      if [[ "$run_integration" == "true" ]]; then
+        echo >&2 -e "\033[1;34mRunning integration tests...\033[0m"
+        GENERATE_FIXTURES=false bats tests/
+      fi
+
     subcommands:
       generate:
+        argparser: true
         desc: Generates the fixtures for the tests
         run: |
           GENERATE_FIXTURES=true bats --filter-tags generate tests/ "$@"
 
       renumber:
+        argparser: true
         desc: Renumber the bats tests
         run: |
           set -e
@@ -126,6 +158,7 @@ commands:
           done
 
   fix:
+    argparser: true
     desc: Fixes the code
     run: |
       set -e

src/internal/cache/up_environments_test.rs

@@ -465,21 +465,23 @@ mod up_environment {
 
     #[test]
     fn test_paths() {
-        let mut env = UpEnvironment::new();
-        let data_home_path = PathBuf::from(data_home()).join("test");
-        let regular_path = PathBuf::from("/usr/local/bin");
+        run_with_env(&[], || {
+            let mut env = UpEnvironment::new();
+            let data_home_path = PathBuf::from(data_home()).join("test");
+            let regular_path = PathBuf::from("/usr/local/bin");
 
-        // Test adding single path
-        assert!(env.add_path(regular_path.clone()));
-        assert_eq!(env.paths.len(), 1);
+            // Test adding single path
+            assert!(env.add_path(regular_path.clone()));
+            assert_eq!(env.paths.len(), 1);
 
-        // Test data_home path gets prepended
-        assert!(env.add_path(data_home_path.clone()));
-        assert_eq!(env.paths[0], data_home_path);
+            // Test data_home path gets prepended
+            assert!(env.add_path(data_home_path.clone()));
+            assert_eq!(env.paths[0], data_home_path);
 
-        // Test adding multiple paths
-        assert!(env.add_paths(vec![PathBuf::from("/path1"), PathBuf::from("/path2")]));
-        assert_eq!(env.paths.len(), 4);
+            // Test adding multiple paths
+            assert!(env.add_paths(vec![PathBuf::from("/path1"), PathBuf::from("/path2")]));
+            assert_eq!(env.paths.len(), 4);
+        });
     }
 
     #[test]

src/internal/config/up/mise.rs

@@ -47,7 +47,7 @@ use crate::internal::env::cache_home;
 use crate::internal::env::current_dir;
 use crate::internal::env::data_home;
 use crate::internal::env::state_home;
-use crate::internal::git::is_path_gitignored;
+use crate::internal::git::is_path_gitignored_from;
 use crate::internal::git_env;
 use crate::internal::user_interface::StringColor;
 use crate::internal::workdir;
@@ -1537,6 +1537,8 @@ impl UpConfigMise {
         detect_version_funcs.push(detect_version_from_tool_version_file);
 
         let in_repo = git_env(".").in_repo();
+        let wd = workdir(".");
+        let wd_root = wd.root();
         for search_dir in search_dirs.iter() {
             // For safety, we remove any leading slashes from the search directory,
             // as we only want to search in the workdir
@@ -1577,7 +1579,9 @@ impl UpConfigMise {
                     {
                         // Check if the entry is .gitignore'd, we do this now for now as it
                         // seems less costly than evaluating all files ahead of time
-                        if in_repo && matches!(is_path_gitignored(entry.path()), Ok(true)) {
+                        if in_repo
+                            && matches!(is_path_gitignored_from(entry.path(), wd_root), Ok(true))
+                        {
                             continue;
                         }
 

src/internal/git/mod.rs

@@ -8,6 +8,7 @@ pub(crate) use utils::format_path_with_template;
 pub(crate) use utils::full_git_url_parse;
 pub(crate) use utils::id_from_git_url;
 pub(crate) use utils::is_path_gitignored;
+pub(crate) use utils::is_path_gitignored_from;
 pub(crate) use utils::package_path_from_git_url;
 pub(crate) use utils::package_path_from_handle;
 pub(crate) use utils::package_root_path;

src/internal/git/utils.rs

@@ -182,21 +182,28 @@ pub fn path_entry_config<T: AsRef<str>>(path: T) -> PathEntryConfig {
 ///
 /// # Arguments
 /// * `file_path` - The path to the file to check
+/// * `root` - Optional root directory to be used as the git repository root. If None, the function
+///   will search for the repository from the file's directory.
 ///
 /// # Returns
 /// * `Ok(bool)` - True if the file is ignored, false otherwise
 /// * `Err(Box<dyn Error>)` - If there's an error accessing the repository or the path
 ///
 /// # Example
 /// ```rust
-/// let is_ignored = is_path_gitignored("src/temp.log")?;
+/// let is_ignored = is_path_gitignored_from("src/temp.log", "path/to/repo").unwrap();
 /// println!("Is file ignored: {}", is_ignored);
 /// ```
-pub fn is_path_gitignored<P: AsRef<Path>>(path: P) -> Result<bool, Box<dyn std::error::Error>> {
+pub fn is_path_gitignored_from<P1: AsRef<Path>, P2: AsRef<Path>>(
+    path: P1,
+    root: Option<P2>,
+) -> Result<bool, Box<dyn std::error::Error>> {
     let path = path.as_ref();
 
     // Find the directory to start the repository search from
-    let search_dir = if path.is_dir() {
+    let search_dir = if let Some(root) = root {
+        root.as_ref().to_path_buf()
+    } else if path.is_dir() {
         path.to_path_buf()
     } else {
         // If it's a file or doesn't exist, use its parent directory
@@ -238,3 +245,15 @@ pub fn is_path_gitignored<P: AsRef<Path>>(path: P) -> Result<bool, Box<dyn std::
         }
     }
 }
+
+/// Checks if a given file path is ignored by Git according to .gitignore rules
+///
+/// This is a convenience wrapper around `is_path_gitignored_from` that does not require
+/// a root directory. It will search for the Git repository starting from the file's directory.
+pub fn is_path_gitignored<P: AsRef<Path>>(path: P) -> Result<bool, Box<dyn std::error::Error>> {
+    is_path_gitignored_from(path, None::<&Path>)
+}
+
+#[cfg(test)]
+#[path = "utils_test.rs"]
+mod test;