Symlink custom deployed folders

Author: ChrisDKN

Changelog.txt

@@ -3,6 +3,8 @@
 - Tweaked ue5 conflict detection to stop showing false conflicts
 - Fixed a bug where a renamed separator would still behave as if it had it's old name
 - Added Street Fighter 6
+- The Data tab filetree no longer auto collapses when enabling, disabling or moving a mod
+- Added a filter option to the ini files tab, The ini files tab also shows more file types
 
 - v1.3.4
 - Added a Skygen and plugin audit wizard

src/Utils/deploy_standard.py

@@ -186,6 +186,15 @@ def deploy_filemap(
     # {custom_deploy_dir_str: {top_level_folder_name, ...}} — populated as we
     # build tasks, consumed by the folder-replace pass below.
     _custom_top_roots: dict[str, set[str]] = {}
+    # {(custom_deploy_dir_str, top_folder_lower): owner_mod_name or None} —
+    # records which mod owns each top-level folder. None means multiple mods
+    # contribute to it (so we fall back to per-file deploy instead of a
+    # single directory symlink). Folders ending up with exactly one owner are
+    # candidates for the directory-symlink optimization.
+    _top_folder_owner: dict[tuple[str, str], str | None] = {}
+    # {(custom_deploy_dir_str, top_folder_lower): one (src_str, rel_str) pair}
+    # — used to derive the source-side top-level folder path for the symlink.
+    _top_folder_sample: dict[tuple[str, str], tuple[str, str]] = {}
     for line in _tab_lines:
         rel_str, mod_name = line.split("\t", 1)
         # Guard against path traversal in filemap entries.
@@ -244,7 +253,15 @@ def deploy_filemap(
         # their top-level folders are merged with the target instead of
         # wholesale-replaced; per-file backup-and-replace still applies.
         if is_custom_task and "/" in rel_str and mod_name not in _per_merge:
-            _custom_top_roots.setdefault(_eff_s, set()).add(rel_str.split("/", 1)[0])
+            _top = rel_str.split("/", 1)[0]
+            _custom_top_roots.setdefault(_eff_s, set()).add(_top)
+            _key = (_eff_s, _top.lower())
+            _existing_owner = _top_folder_owner.get(_key, "__unset__")
+            if _existing_owner == "__unset__":
+                _top_folder_owner[_key] = mod_name
+                _top_folder_sample[_key] = (src_str, rel_str)
+            elif _existing_owner != mod_name:
+                _top_folder_owner[_key] = None  # multi-owner → no dir-symlink
 
         if progress_fn is not None and line_idx % 500 == 0:
             progress_fn(line_idx, total_lines)
@@ -309,6 +326,88 @@ def deploy_filemap(
             _resolved_dir_cache.pop(_existing_dir_str.lower(), None)
             _dir_listing_cache.pop(os.path.dirname(_existing_dir_str), None)
 
+    # Directory-symlink pass: for every single-owner top-level folder we just
+    # replaced above, drop a directory symlink <dest>/<top> → <staging>/<mod>/<src_top>.
+    # New files written by the game land directly in the mod's staging dir
+    # (no manual sync on restore needed). Tasks that fall under one of these
+    # symlinked folders are excluded from the per-file deploy below.
+    _dir_symlink_log: list[str] = []
+    _skipped_task_prefixes: set[str] = set()
+    for (_eff_dir_s, _top_lower), _owner in _top_folder_owner.items():
+        if _owner is None:
+            continue
+        _sample = _top_folder_sample.get((_eff_dir_s, _top_lower))
+        if _sample is None:
+            continue
+        _sample_src, _sample_rel = _sample
+        # Derive the source-side folder path: rel_str is e.g. "Saves/foo.ess"
+        # and src_str ends in "<staging>/<mod>/<resolved>/Saves/foo.ess" (the
+        # resolved part may include strip_prefix folders). Walk parents of
+        # src_str up by the number of "/" components in rel_str minus one to
+        # land on the source-side top-level folder.
+        _rel_depth = _sample_rel.count("/")  # files-deep below the top folder
+        _src_top = _sample_src
+        for _ in range(_rel_depth):
+            _src_top = os.path.dirname(_src_top)
+        if not os.path.isdir(_src_top):
+            # Couldn't resolve a real source directory — fall back to per-file.
+            continue
+        # Destination path uses the same case-resolved form as per-file deploy.
+        _dst_top = _resolve_root_path_str(
+            _eff_dir_s, _sample_rel.split("/", 1)[0], _dir_listing_cache,
+            resolved_dir_cache=_resolved_dir_cache,
+        )
+        # The wholesale-replace pass above moved any vanilla folder away, so
+        # the dest path should not exist; create the parent dir, then symlink.
+        try:
+            os.makedirs(os.path.dirname(_dst_top), exist_ok=True)
+            # Defensive: drop a leftover empty dir or stale symlink at the spot
+            try:
+                _existing_st = os.lstat(_dst_top)
+                if _stat_module.S_ISLNK(_existing_st.st_mode):
+                    os.unlink(_dst_top)
+                elif _stat_module.S_ISDIR(_existing_st.st_mode):
+                    try:
+                        os.rmdir(_dst_top)
+                    except OSError:
+                        # Non-empty — bail; per-file deploy will handle it.
+                        continue
+            except OSError:
+                pass
+            os.symlink(_src_top, _dst_top)
+            _dir_symlink_log.append(_dst_top)
+            _skipped_task_prefixes.add(_dst_top.rstrip("/") + "/")
+            _log(f"  Symlinked folder {os.path.basename(_dst_top)}/ → {_src_top}")
+        except OSError as exc:
+            _log(f"  WARN: could not symlink folder {_dst_top}: {exc}")
+
+    # Filter out tasks whose destination falls under a directory-symlinked
+    # folder — they're already covered by the symlink.
+    if _skipped_task_prefixes:
+        def _under_symlinked(dst: str) -> bool:
+            for _pfx in _skipped_task_prefixes:
+                if dst.startswith(_pfx):
+                    return True
+            return False
+        before_count = len(tasks)
+        tasks = [t for t in tasks if not _under_symlinked(t[1])]
+        # Mark every skipped rel_lower as "placed" so deploy_core() doesn't
+        # try to provide a vanilla fallback for these paths.
+        for _line in _tab_lines:
+            if "\t" not in _line:
+                continue
+            _rs, _mn = _line.rstrip("\n").split("\t", 1)
+            _dst_check = _resolve_root_path_str(
+                str(_per_deploy.get(_mn, deploy_dir)) if _mn in _per_deploy else _deploy_dir_str,
+                _rs, _dir_listing_cache, resolved_dir_cache=_resolved_dir_cache,
+            )
+            if _under_symlinked(_dst_check):
+                placed_lower.add(_rs.lower())
+        print(f"  [TIMER] deploy_filemap — directory-symlink pass: skipped "
+              f"{before_count - len(tasks)} per-file task(s) under "
+              f"{len(_skipped_task_prefixes)} folder symlink(s).")
+    total = len(tasks)
+
     # Pre-create all destination directories up front (single-threaded) to
     # avoid mkdir races inside the thread pool.
     with _timer("deploy_filemap — mkdir"):
@@ -370,12 +469,14 @@ def _do_transfer(item: tuple[str, str, str, bool, bool, "LinkMode | None"]) -> t
     print(f"  [TIMER] deploy_filemap — transfer {total} files: {_time.perf_counter() - _t_transfer:.3f}s")
 
     # Write a log of files placed in custom locations so cleanup knows what to
-    # remove.  Each line is the absolute path of a deployed file.
+    # remove.  Each line is the absolute path of a deployed file (or a
+    # directory symlink we created via the dir-symlink pass).
     custom_deployed = [
         dst
         for _src, dst, rel_lower, is_custom, _use_sym, _ov in tasks
         if is_custom and rel_lower in placed_lower
     ]
+    custom_deployed.extend(_dir_symlink_log)
     try:
         if custom_deployed:
             _custom_log_path.write_text("\n".join(custom_deployed), encoding="utf-8")

src/version.py

@@ -1 +1 @@
-__version__ = "1.3.5-beta.3"
+__version__ = "1.3.5-beta.4"