Improves search up

Author: timonweb

easy_django_cli/cli.py

@@ -10,8 +10,12 @@
     "__pycache__",  # Python cache
     "node_modules",  # JavaScript dependencies
     "static", "build", "dist",  # Build artifacts
+    "logs", "log", "tmp",  # Log directories
+    "media"  # Media upload directories
 ])
 
+TOP_LEVEL_SEARCH_MAX_DEPTH = 3  # Max depth to search if no top-level dir is found
+
 
 def run_manage_py_command(manage_py_path: Path, args: list[str]) -> int:
     """
@@ -96,9 +100,9 @@ def execute_django_command(manage_py_path: Optional[Path] = None) -> int:
 
 
 def _find_files_scan_dir(
-    directory: Path | str,
-    filename: str,
-    skip_dirs: frozenset[str]
+        directory: Path | str,
+        filename: str,
+        skip_dirs: frozenset[str]
 ) -> Optional[str]:
     """
     Recursively scan a directory tree for a specific filename.
@@ -137,14 +141,15 @@ def _find_files_scan_dir(
                 if result := _find_files_scan_dir(dir_path, filename, skip_dirs):
                     return result
 
-    except PermissionError:
-        # Skip directories without read permission (common in system directories)
+    except (PermissionError, OSError):
+        # Skip directories without read permission or with other OS-level errors
+        # (common in system directories, special filesystems, etc.)
         pass
 
     return None
 
 
-def find_manage_py(start_path: Optional[Path] = None) -> Optional[Path]:
+def find_manage_py() -> Optional[Path]:
     """
     Locate Django's manage.py file by recursively searching upward through parent directories.
 
@@ -153,37 +158,63 @@ def find_manage_py(start_path: Optional[Path] = None) -> Optional[Path]:
     subdirectories. This approach finds manage.py even if it's in a sibling directory
     or nested subdirectory relative to the starting point.
 
-    Args:
-        start_path: Directory to start searching from (defaults to current directory)
+    The search stops at natural boundaries (git repository root, home directory, or
+    filesystem root) to avoid scanning unrelated projects.
 
     Returns:
         Path object pointing to manage.py if found, None otherwise
     """
-    if start_path is None:
-        start_path = Path.cwd()
-
-    current = start_path.resolve()
+    current = Path.cwd().resolve()
     search_current = current
+    top_level_dir = _get_top_level_directory()
+    level = 0
 
     # Search upward through directory hierarchy
     while True:
         # Recursively search current level and all subdirectories
         if manage_py_str := _find_files_scan_dir(
-            search_current, "manage.py", SKIP_DIRS
+                search_current, "manage.py", SKIP_DIRS
         ):
             return Path(manage_py_str)
 
+        # Stop at natural boundaries to avoid searching unrelated projects
+        # Stop if we find a .git directory (project root marker)
+        if (search_current / ".git").exists():
+            # We've searched this git repo and didn't find manage.py
+            break
+
+        # If we don't have a top level directory, we limit search depth to avoid system-wide search
+        if not top_level_dir and level >= TOP_LEVEL_SEARCH_MAX_DEPTH:
+            return None
+
+        # Stop at top level directory searching system-wide
+        if search_current == top_level_dir:
+            break
+
         # Move to parent directory
         parent = search_current.parent
         if parent == search_current:
             # Reached filesystem root without finding manage.py
             break
 
         search_current = parent
+        level += 1
 
     return None
 
 
+def _get_top_level_directory() -> Optional[Path]:
+    """
+    Determine the top-level directory to limit manage.py search.
+    """
+    try:
+        from django.conf import settings
+        if base_dir := getattr(settings, "BASE_DIR", None):
+            return Path(base_dir).parent.resolve()
+    except Exception:
+        return None
+
+
 def main() -> int:
     """
     Main entry point for the easy-django CLI tool.

tests/test_cli.py

@@ -2,7 +2,12 @@
 from pathlib import Path
 from unittest.mock import patch
 
-from easy_django_cli.cli import execute_django_command, find_manage_py, main
+from easy_django_cli.cli import (
+    _get_top_level_directory,
+    execute_django_command,
+    find_manage_py,
+    main,
+)
 
 
 class TestFindManagePy:
@@ -12,55 +17,240 @@ def test_find_manage_py_in_current_dir(self, temp_dir: Path) -> None:
         WHEN: Searching for manage.py in that directory
         THEN: The manage.py file should be found
         """
+        import os
+
         manage_py = temp_dir / "manage.py"
         manage_py.write_text("# manage.py")
 
-        result = find_manage_py(temp_dir)
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(temp_dir)
+            result = find_manage_py()
 
-        assert result is not None
-        assert result.resolve() == manage_py.resolve()
+            assert result is not None
+            assert result.resolve() == manage_py.resolve()
+        finally:
+            os.chdir(original_cwd)
 
     def test_find_manage_py_in_parent_dir(self, temp_dir: Path) -> None:
         """
         GIVEN: A parent directory with manage.py and a subdirectory
         WHEN: Searching for manage.py from the subdirectory
         THEN: The manage.py in the parent directory should be found
         """
+        import os
+
         manage_py = temp_dir / "manage.py"
         manage_py.write_text("# manage.py")
         subdir = temp_dir / "subdir"
         subdir.mkdir()
 
-        result = find_manage_py(subdir)
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(subdir)
+            result = find_manage_py()
 
-        assert result is not None
-        assert result.resolve() == manage_py.resolve()
+            assert result is not None
+            assert result.resolve() == manage_py.resolve()
+        finally:
+            os.chdir(original_cwd)
 
     def test_find_manage_py_not_found(self, temp_dir: Path) -> None:
         """
         GIVEN: A directory without manage.py file
         WHEN: Searching for manage.py in that directory
         THEN: No manage.py should be found
         """
-        result = find_manage_py(temp_dir)
+        import os
 
-        assert result is None
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(temp_dir)
+            result = find_manage_py()
+
+            assert result is None
+        finally:
+            os.chdir(original_cwd)
 
     def test_find_manage_py_max_depth(self, temp_dir: Path) -> None:
         """
         GIVEN: A manage.py at the root and a deeply nested directory
         WHEN: Searching for manage.py from the deeply nested directory
         THEN: The manage.py at the root should be found
         """
+        import os
+
+        manage_py = temp_dir / "manage.py"
+        manage_py.write_text("# manage.py")
+        deep_dir = temp_dir / "a" / "b" / "c"
+        deep_dir.mkdir(parents=True)
+
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(deep_dir)
+            result = find_manage_py()
+
+            assert result is not None
+            assert result.resolve() == manage_py.resolve()
+        finally:
+            os.chdir(original_cwd)
+
+    def test_find_manage_py_max_depth_fails(self, temp_dir: Path) -> None:
+        """
+        GIVEN: A manage.py beyond the max search depth
+        WHEN: Searching for manage.py from a deeply nested directory
+        THEN: No manage.py should be found
+        """
+        import os
+
         manage_py = temp_dir / "manage.py"
         manage_py.write_text("# manage.py")
-        deep_dir = temp_dir / "a" / "b" / "c" / "d" / "e" / "f"
+        deep_dir = temp_dir / "a" / "b" / "c" / "d"
         deep_dir.mkdir(parents=True)
 
-        result = find_manage_py(deep_dir)
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(deep_dir)
+            result = find_manage_py()
+
+            assert result is None
+        finally:
+            os.chdir(original_cwd)
+
+    def test_find_manage_py_stops_at_git_boundary(self, temp_dir: Path) -> None:
+        """
+        GIVEN: A git repository without manage.py and a parent directory with manage.py
+        WHEN: Searching for manage.py from inside the git repo
+        THEN: The search should stop at the git boundary and not find the parent's manage.py
+        """
+        import os
+
+        # Create a manage.py in the parent directory
+        parent_manage_py = temp_dir / "manage.py"
+        parent_manage_py.write_text("# parent manage.py")
+
+        # Create a subdirectory with .git (simulating a git repo)
+        git_repo = temp_dir / "git_repo"
+        git_repo.mkdir()
+        git_dir = git_repo / ".git"
+        git_dir.mkdir()
+
+        # Create a subdirectory inside the git repo
+        subdir = git_repo / "subdir"
+        subdir.mkdir()
+
+        # Change to the subdir and search from there
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(subdir)
+            result = find_manage_py()
+
+            # Should not find the parent's manage.py due to git boundary
+            assert result is None
+        finally:
+            os.chdir(original_cwd)
+
+    def test_find_manage_py_finds_within_git_repo(self, temp_dir: Path) -> None:
+        """
+        GIVEN: A git repository with manage.py inside it
+        WHEN: Searching for manage.py from a subdirectory in the repo
+        THEN: The manage.py inside the git repo should be found
+        """
+        import os
+
+        # Create a git repo directory with .git
+        git_repo = temp_dir / "git_repo"
+        git_repo.mkdir()
+        git_dir = git_repo / ".git"
+        git_dir.mkdir()
+
+        # Create manage.py inside the git repo
+        manage_py = git_repo / "manage.py"
+        manage_py.write_text("# manage.py")
+
+        # Create a subdirectory inside the git repo
+        subdir = git_repo / "subdir"
+        subdir.mkdir()
+
+        # Change to the subdir and search from there
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(subdir)
+            result = find_manage_py()
+
+            # Should find manage.py inside the git repo
+            assert result is not None
+            assert result.resolve() == manage_py.resolve()
+        finally:
+            os.chdir(original_cwd)
+
+
+class TestGetTopLevelDirectory:
+    def test_get_top_level_directory_no_django(self) -> None:
+        """
+        GIVEN: Django is not installed or not configured
+        WHEN: Calling _get_top_level_directory
+        THEN: Should return None without raising exceptions
+        """
+        result = _get_top_level_directory()
+
+        # Should handle missing Django gracefully
+        assert result is None
+
+    def test_get_top_level_directory_with_django_configured(
+        self, temp_dir: Path
+    ) -> None:
+        """
+        GIVEN: Django is configured with BASE_DIR in settings
+        WHEN: Calling _get_top_level_directory
+        THEN: Should return the parent of BASE_DIR
+        """
+        # Create a mock settings module with BASE_DIR
+        base_dir = temp_dir / "project"
+        base_dir.mkdir()
+
+        with patch("django.conf.settings") as mock_settings:
+            mock_settings.BASE_DIR = str(base_dir)
+            result = _get_top_level_directory()
+
+            assert result is not None
+            assert result.resolve() == temp_dir.resolve()
+
+    def test_get_top_level_directory_no_base_dir(self) -> None:
+        """
+        GIVEN: Django is configured but settings has no BASE_DIR
+        WHEN: Calling _get_top_level_directory
+        THEN: Should return None
+        """
+        with patch("django.conf.settings") as mock_settings:
+            # Mock settings without BASE_DIR attribute
+            del mock_settings.BASE_DIR
+            mock_settings.BASE_DIR = None
+
+            result = _get_top_level_directory()
+
+            assert result is None
+
+    def test_get_top_level_directory_handles_improperly_configured(self) -> None:
+        """
+        GIVEN: Django raises ImproperlyConfigured when accessing settings
+        WHEN: Calling _get_top_level_directory
+        THEN: Should return None without raising exceptions
+        """
+        from django.core.exceptions import ImproperlyConfigured
+
+        with patch("django.conf.settings") as mock_settings:
+            # Simulate ImproperlyConfigured error
+            type(mock_settings).BASE_DIR = property(
+                lambda self: (_ for _ in ()).throw(
+                    ImproperlyConfigured("Django is not configured")
+                )
+            )
+
+            result = _get_top_level_directory()
 
-        assert result is not None
-        assert result.resolve() == manage_py.resolve()
+            # Should catch the exception and return None
+            assert result is None
 
 
 class TestExecuteDjangoCommand: