feat: verbose argument (#251)

added verbose argv to print all folders that will be deleted on dry run

Author: Romamo

README.md

@@ -122,6 +122,7 @@ options:
   -c, --configure    Open module configuration screen
   -p, --custom-path  Specify path for custom modules
   -f, --force        Accept all warnings
+  -v, --verbose      Print folders to be deleted
 
 ```
 

mac_cleanup/core.py

@@ -4,7 +4,7 @@
 from itertools import chain
 from pathlib import Path as Path_
 from types import TracebackType
-from typing import Any, Final, Optional, Type, TypeGuard, TypeVar, final
+from typing import Any, Final, Generator, Optional, Type, TypeGuard, TypeVar, final
 
 import attr
 from beartype import beartype  # pyright: ignore [reportUnknownVariableType]
@@ -192,8 +192,8 @@ def __filter_modules(module_: BaseModule, filter_type: Type[T]) -> TypeGuard[T]:
 
         return isinstance(module_, filter_type)
 
-    def _count_dry(self) -> float:
-        """Counts free space for dry run :return: Approx amount of bytes to be removed."""
+    def _extract_paths(self) -> Generator[tuple[Path_, float], None, None]:
+        """Extracts all paths from the collector :return: Yields paths with size."""
 
         from concurrent.futures import ThreadPoolExecutor, as_completed
 
@@ -208,28 +208,29 @@ def _count_dry(self) -> float:
         # Extracts paths from path_modules list
         path_list: list[Path_] = [path.get_path for path in path_modules]
 
-        # Set counter for estimated size
-        estimate_size: float = 0
-
         # Get thread executor
         executor = ThreadPoolExecutor()
 
         try:
             # Add tasks to executor
             tasks = [executor.submit(self._get_size, path) for path in path_list]
 
+            # Store paths and their corresponding futures
+            path_future_zip = list(zip(path_list, tasks, strict=True))
+
             # Wait for task completion and add ProgressBar
             for future in ProgressBar.wrap_iter(
                 as_completed(tasks), description="Collecting dry run", total=len(path_list)
             ):
-                estimate_size += future.result(timeout=10)
+                path = next(p for p, f in path_future_zip if f == future)
+                size = future.result(timeout=10)
+                yield path, size
         except KeyboardInterrupt:
             # Shutdown executor without waiting for tasks
             executor.shutdown(wait=False)
         else:
             # Cleanup executor
             executor.shutdown(wait=True)
-        return estimate_size
 
 
 class ProxyCollector:

mac_cleanup/main.py

@@ -71,7 +71,14 @@ def start(self) -> None:
         if args.dry_run:
             from rich.prompt import Confirm
 
-            freed_space = bytes_to_human(self.base_collector._count_dry())  # noqa
+            estimate_size: float = 0
+
+            for path, size in self.base_collector._extract_paths():
+                if args.verbose and size:
+                    console.print(bytes_to_human(size), path, no_wrap=True)
+                estimate_size += size
+
+            freed_space = bytes_to_human(estimate_size)  # noqa
 
             print_panel(text=f"Approx [success]{freed_space}[/success] will be cleaned", title="[info]Dry run results")
 

mac_cleanup/parser.py

@@ -16,6 +16,7 @@ class Args:
     configure: bool = attr.ib(default=False)
     custom_path: bool = attr.ib(default=False)
     force: bool = attr.ib(default=False)
+    verbose: bool = attr.ib(default=False)
 
 
 parser = ArgumentParser(
@@ -37,10 +38,13 @@ class Args:
 
 parser.add_argument("-f", "--force", help="Accept all warnings", action="store_true")
 
+parser.add_argument("-v", "--verbose", help="Print folders to be deleted", action="store_true")
+
 args = Args()
 parser.parse_args(namespace=args)
 
 # args.dry_run = True  # debug
 # args.configure = True  # debug
 # args.custom_path = True  # debug
 # args.force = True  # debug
+# args.verbose = True # debug

tests/test_core.py

@@ -194,8 +194,8 @@ def dummy_path_stat(console_self: Pathlib, follow_symlinks: bool) -> None:  # no
         base_collector._get_size(Pathlib("/"))
 
     @pytest.mark.parametrize("size_multiplier", [0, 1, 1024])
-    def test_count_dry(self, size_multiplier: int, base_collector: _Collector, monkeypatch: MonkeyPatch):
-        """Test :meth:`mac_cleanup.core._Collector._count_dry`"""
+    def test_extract_paths(self, size_multiplier: int, base_collector: _Collector, monkeypatch: MonkeyPatch):
+        """Test :meth:`mac_cleanup.core._Collector._extract_paths`"""
 
         # Get size in bytes
         size = 1024 * size_multiplier
@@ -209,11 +209,16 @@ def test_count_dry(self, size_multiplier: int, base_collector: _Collector, monke
         # Simulate stuff in execute_list
         monkeypatch.setattr(base_collector, "_execute_list", [Unit(message="test", modules=[Path("~/test")])])
 
+        # Call _extract_paths
+        paths = list(base_collector._extract_paths())
+
         # Check results
-        assert base_collector._count_dry() == size
+        assert len(paths) == 1
+        assert paths[0][0] == Path("~/test").get_path
+        assert paths[0][1] == size
 
-    def test_count_dry_error(self, base_collector: _Collector, monkeypatch: MonkeyPatch):
-        """Test errors in :meth:`mac_cleanup.core._Collector._count_dry`"""
+    def test_extract_paths_error(self, base_collector: _Collector, monkeypatch: MonkeyPatch):
+        """Test errors in :meth:`mac_cleanup.core._Collector._extract_paths`"""
 
         # Dummy get size raising KeyboardInterrupt
         def dummy_get_size(clc_self: _Collector, path: Pathlib) -> float:  # noqa  # noqa
@@ -226,4 +231,8 @@ def dummy_get_size(clc_self: _Collector, path: Pathlib) -> float:  # noqa  # noq
         monkeypatch.setattr(base_collector, "_execute_list", [Unit(message="test", modules=[Path("~/test")])])
 
         # Check prematurely exit return 0
-        assert base_collector._count_dry() == 0
+        # Call _extract_paths
+        paths = list(base_collector._extract_paths())
+
+        # Check results
+        assert len(paths) == 0

tests/test_main.py

@@ -105,11 +105,14 @@ def dummy_count_free_space(entry_self: EntryPoint) -> float:  # noqa
         assert f"Removed - {size_multiplier / 2} GB" in captured_stdout
 
     @pytest.mark.parametrize("cleanup_prompted", [True, False])
-    def test_dry_run_prompt(self, cleanup_prompted: bool, capsys: CaptureFixture[str], monkeypatch: MonkeyPatch):
-        """Test dry_run with optional cleanup in :class:`mac_cleanup.main.EntryPoint`"""
+    @pytest.mark.parametrize("verbose", [True, False])
+    def test_dry_run_prompt(
+        self, cleanup_prompted: bool, verbose: bool, capsys: CaptureFixture[str], monkeypatch: MonkeyPatch
+    ):
+        """Test dry_run with verbose and optional cleanup in :class:`mac_cleanup.main.EntryPoint`"""
 
-        # Dummy count_dry returning 1 GB
-        dummy_count_dry: Callable[..., float] = lambda: float(1024**3)
+        # Dummy _extract_paths returning [Pathlib("test") and 1 GB]
+        dummy_extract_paths: Callable[..., list[tuple[Pathlib, float]]] = lambda: [(Pathlib("test"), float(1024**3))]
 
         # Dummy Config with empty init
         def dummy_config_init(cfg_self: Config, config_path_: Pathlib) -> None:  # noqa  # noqa
@@ -136,15 +139,18 @@ def dummy_config_call(config_path_: Pathlib, configuration_prompted: bool) -> No
         mock_entry_point = EntryPoint()
         monkeypatch.setattr(EntryPoint, "__new__", lambda: mock_entry_point)
 
-        # Simulate count_dry with predefined result
-        monkeypatch.setattr(mock_entry_point.base_collector, "_count_dry", dummy_count_dry)
+        # Simulate _extract_paths with predefined result
+        monkeypatch.setattr(mock_entry_point.base_collector, "_extract_paths", dummy_extract_paths)
 
         # Simulate empty cleanup
         monkeypatch.setattr(EntryPoint, "cleanup", dummy_cleanup)
 
         # Simulate dry run was prompted
         monkeypatch.setattr("mac_cleanup.parser.Args.dry_run", True)
 
+        # Simulate verbose was set
+        monkeypatch.setattr("mac_cleanup.parser.Args.verbose", verbose)
+
         # Call entrypoint
         main()
 
@@ -155,15 +161,23 @@ def dummy_config_call(config_path_: Pathlib, configuration_prompted: bool) -> No
         assert "Dry run results" in captured_stdout
         assert "Approx 1.0 GB will be cleaned" in captured_stdout
 
+        # Check verbose message
+        if verbose:
+            assert "1.0 GB test" in captured_stdout
+
+        # Check no verbose message
+        if not verbose:
+            assert "1.0 GB test" not in captured_stdout
+
         # Check exit message
         if not cleanup_prompted:
             assert "Exiting..." in captured_stdout
 
     def test_dry_run_prompt_error(self, capsys: CaptureFixture[str], monkeypatch: MonkeyPatch):
         """Test errors in dry_run in :class:`mac_cleanup.main.EntryPoint`"""
 
-        # Dummy count_dry returning 1 GB
-        dummy_count_dry: Callable[..., float] = lambda: float(1024**3)
+        # Dummy _extract_paths returning [Pathlib("test") and 1 GB]
+        dummy_extract_paths: Callable[..., list[tuple[Pathlib, float]]] = lambda: [(Pathlib("test"), float(1024**3))]
 
         # Dummy Config with no init and empty call
         # Dummy Config with empty init
@@ -189,8 +203,8 @@ def dummy_input(*args: Any, **kwargs: Any) -> None:  # noqa
         mock_entry_point = EntryPoint()
         monkeypatch.setattr(EntryPoint, "__new__", lambda: mock_entry_point)
 
-        # Simulate count_dry with predefined result
-        monkeypatch.setattr(mock_entry_point.base_collector, "_count_dry", dummy_count_dry)
+        # Simulate _extract_paths with predefined result
+        monkeypatch.setattr(mock_entry_point.base_collector, "_extract_paths", dummy_extract_paths)
 
         # Simulate dry run was prompted
         monkeypatch.setattr("mac_cleanup.parser.Args.dry_run", True)