feat: feedback verbetering

2026-03-15 13:28:11 +01:00
parent a52493459a
commit 66abf991d8
15 changed files with 585 additions and 180 deletions
@@ -31,7 +31,11 @@ class DuplicateTaskService:
            items: list[dict[str, str]] = []
            reserved_destinations: set[str] = set()
            for input_path in paths:
-                item = self._build_duplicate_item(input_path, reserved_destinations)
+                item = self._build_duplicate_item(
+                    input_path,
+                    reserved_destinations,
+                    include_root_prefix=len(paths) > 1,
+                )
                if item is None:
                    continue
                reserved_destinations.add(item["destination_absolute"])
@@ -60,6 +64,8 @@ class DuplicateTaskService:
                        "source": item["source_absolute"],
                        "destination": item["destination_absolute"],
                        "kind": item["kind"],
+                        "files": item["files"],
+                        "directories": item["directories"],
                    }
                    for item in items
                ],
@@ -77,7 +83,13 @@ class DuplicateTaskService:
            )
            raise

-    def _build_duplicate_item(self, source: str, reserved_destinations: set[str]) -> dict[str, str] | None:
+    def _build_duplicate_item(
+        self,
+        source: str,
+        reserved_destinations: set[str],
+        *,
+        include_root_prefix: bool,
+    ) -> dict[str, str] | None:
        resolved_source = self._path_guard.resolve_existing_path(source)
        _, _, lexical_source, _ = self._path_guard.resolve_lexical_path(source)
        if self._should_skip_name(lexical_source.name):
@@ -100,9 +112,6 @@ class DuplicateTaskService:
                details={"path": source},
            )

-        if source_is_directory:
-            self._validate_directory_tree(resolved_source)
-
        destination_absolute = self._next_duplicate_destination(resolved_source.absolute, reserved_destinations)
        destination_relative = self._path_guard.entry_relative_path(
            resolved_source.alias,
@@ -110,19 +119,68 @@ class DuplicateTaskService:
            display_style=resolved_source.display_style,
        )

+        if source_is_directory:
+            directories, files = self._build_directory_plan(
+                resolved_source=resolved_source,
+                destination_root=destination_absolute,
+                include_root_prefix=include_root_prefix,
+            )
+        else:
+            files = [
+                {
+                    "source": str(resolved_source.absolute),
+                    "destination": str(destination_absolute),
+                    "label": resolved_source.absolute.name,
+                }
+            ]
+            directories = []
+
        return {
            "source_relative": resolved_source.relative,
            "destination_relative": destination_relative,
            "source_absolute": str(resolved_source.absolute),
            "destination_absolute": str(destination_absolute),
            "kind": "directory" if source_is_directory else "file",
+            "files": files,
+            "directories": directories,
        }

-    def _validate_directory_tree(self, resolved_source: ResolvedPath) -> None:
+    def _build_directory_plan(
+        self,
+        *,
+        resolved_source: ResolvedPath,
+        destination_root: Path,
+        include_root_prefix: bool,
+    ) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
+        directories: list[dict[str, str]] = [
+            {
+                "source": str(resolved_source.absolute),
+                "destination": str(destination_root),
+            }
+        ]
+        files: list[dict[str, str]] = []
        for root, dirnames, filenames in os.walk(resolved_source.absolute, followlinks=False):
            dirnames[:] = [name for name in dirnames if not self._should_skip_name(name)]
+            dirnames.sort(key=str.lower)
+            filenames = sorted(filenames, key=str.lower)
            root_path = Path(root)
-            for name in [*dirnames, *filenames]:
+            for name in dirnames:
+                entry = root_path / name
+                if entry.is_symlink():
+                    raise AppError(
+                        code="type_conflict",
+                        message="Source directory must not contain symlinks",
+                        status_code=409,
+                        details={"path": resolved_source.relative},
+                    )
+                relative = entry.relative_to(resolved_source.absolute)
+                directories.append(
+                    {
+                        "source": str(entry),
+                        "destination": str(destination_root / relative),
+                    }
+                )
+            for name in filenames:
                if self._should_skip_name(name):
                    continue
                entry = root_path / name
@@ -133,6 +191,26 @@ class DuplicateTaskService:
                        status_code=409,
                        details={"path": resolved_source.relative},
                    )
+                relative = entry.relative_to(resolved_source.absolute)
+                files.append(
+                    {
+                        "source": str(entry),
+                        "destination": str(destination_root / relative),
+                        "label": self._progress_label(
+                            top_level_name=resolved_source.absolute.name,
+                            relative_path=relative,
+                            include_root_prefix=include_root_prefix,
+                        ),
+                    }
+                )
+        return directories, files
+
+    @staticmethod
+    def _progress_label(*, top_level_name: str, relative_path: Path, include_root_prefix: bool) -> str:
+        relative_value = relative_path.as_posix()
+        if not relative_value:
+            return top_level_name
+        return f"{top_level_name}/{relative_value}" if include_root_prefix else relative_value

    @classmethod
    def _next_duplicate_destination(cls, source: Path, reserved_destinations: set[str]) -> Path: