Improve naming and caching

Author: PawelLipski

git_machete/client/base.py

@@ -112,7 +112,7 @@ def __init__(self, git: GitContext) -> None:
     def __get_git_machete_branch_layout_file_path(self) -> str:
         use_top_level_machete_file = self._git.get_boolean_config_attr(key=git_config_keys.WORKTREE_USE_TOP_LEVEL_MACHETE_FILE,
                                                                        default_value=True)
-        machete_file_directory = self._git.get_main_git_dir() if use_top_level_machete_file else self._git.get_worktree_git_dir()
+        machete_file_directory = self._git.get_main_worktree_git_dir() if use_top_level_machete_file else self._git.get_current_worktree_git_dir()
         return os.path.join(machete_file_directory, 'machete')
 
     def __init_state(self) -> None:
@@ -606,7 +606,7 @@ def print_line_prefix(branch_: LocalBranchShortName, suffix: str) -> None:
             if hook_executable:
                 debug(f"running machete-status-branch hook ({hook_path}) for branch {branch}")
                 hook_env = dict(os.environ, ASCII_ONLY=str(utils.ascii_only).lower())
-                status_code, stdout, stderr = self.__popen_hook(hook_path, branch, cwd=self._git.get_root_dir(), env=hook_env)
+                status_code, stdout, stderr = self.__popen_hook(hook_path, branch, cwd=self._git.get_current_worktree_root_dir(), env=hook_env)
 
                 if status_code == 0:
                     if not stdout.isspace():
@@ -683,7 +683,7 @@ def rebase(
         hook_path = self._git.get_hook_path("machete-pre-rebase")
         if self._git.check_hook_executable(hook_path):
             debug(f"running machete-pre-rebase hook ({hook_path})")
-            exit_code = self.__run_hook(hook_path, onto, from_exclusive, branch, cwd=self._git.get_root_dir())
+            exit_code = self.__run_hook(hook_path, onto, from_exclusive, branch, cwd=self._git.get_current_worktree_root_dir())
             if exit_code == 0:
                 self._git.rebase(
                     onto, from_exclusive, branch,
@@ -1032,7 +1032,7 @@ def _run_post_slide_out_hook(
             debug(f"running machete-post-slide-out hook ({hook_path})")
             new_downstreams_strings: List[str] = [str(db) for db in new_downstreams]
             exit_code = self.__run_hook(hook_path, new_upstream, slid_out_branch, *new_downstreams_strings,
-                                        cwd=self._git.get_root_dir())
+                                        cwd=self._git.get_current_worktree_root_dir())
             if exit_code != 0:
                 raise MacheteException(f"The machete-post-slide-out hook exited with {exit_code}, aborting.")
 

git_machete/client/traverse.py

@@ -55,48 +55,42 @@ def _update_worktrees_cache_after_checkout(self, checked_out_branch: LocalBranch
         Only the current worktree's entry needs to be updated - linked worktrees
         don't change when we checkout in a different worktree.
         """
-        current_worktree_path = self._git.get_root_dir()
+        current_worktree_root_dir = self._git.get_current_worktree_root_dir()
 
-        # Remove the old branch entry for this worktree (if any)
-        # We need to find which branch was previously checked out in this worktree
-        for branch, path in self.__worktrees_cache.items():
-            if path == current_worktree_path:  # pragma: no branch
-                del self.__worktrees_cache[branch]
+        for branch, path in self.__worktree_root_dir_for_branch.items():
+            if path == current_worktree_root_dir:  # pragma: no branch
+                del self.__worktree_root_dir_for_branch[branch]
                 break
 
-        # Add the new branch entry for this worktree
-        self.__worktrees_cache[checked_out_branch] = current_worktree_path
+        self.__worktree_root_dir_for_branch[checked_out_branch] = current_worktree_root_dir
 
     def _switch_to_branch_worktree(
             self,
-            branch: LocalBranchShortName) -> None:
+            target_branch: LocalBranchShortName) -> None:
         """
         Switch to the worktree where the branch is checked out, or to main worktree if branch is not checked out.
         This may involve changing the current working directory.
         Updates the worktrees cache after checkout.
         """
-        worktree_path = self.__worktrees_cache.get(branch)
-        current_worktree_root = self._git.get_root_dir()
+        target_worktree_root_dir = self.__worktree_root_dir_for_branch.get(target_branch)
+        current_worktree_root_dir = self._git.get_current_worktree_root_dir()
 
-        if worktree_path is None:
+        if target_worktree_root_dir is None:
             # Branch is not checked out anywhere, need to checkout in main worktree
             # Only cd if we're currently in a different worktree (linked worktree)
-            main_worktree_path = self._git.get_main_worktree_path()
-            if current_worktree_root != main_worktree_path:
-                print(f"Changing directory to main worktree at {bold(main_worktree_path)}")
-                os.chdir(main_worktree_path)
-                # checkout() below will flush all caches, including __root_dir
-            self._git.checkout(branch)
+            main_worktree_root_dir = self._git.get_main_worktree_root_dir()
+            if current_worktree_root_dir != main_worktree_root_dir:
+                print(f"Changing directory to main worktree at {bold(main_worktree_root_dir)}")
+                self._git.chdir(main_worktree_root_dir)
+            self._git.checkout(target_branch)
             # Update cache after checkout
-            self._update_worktrees_cache_after_checkout(branch)
+            self._update_worktrees_cache_after_checkout(target_branch)
         else:
             # Branch is checked out in a worktree
             # Only cd if we're in a different worktree
-            if current_worktree_root != worktree_path:
-                print(f"Changing directory to {bold(worktree_path)} worktree where {bold(branch)} is checked out")
-                os.chdir(worktree_path)
-                # Flush root dir cache after directory change so get_root_dir() returns the correct path
-                self._git.flush_root_dir_cache()
+            if current_worktree_root_dir != target_worktree_root_dir:
+                print(f"Changing directory to {bold(target_worktree_root_dir)} worktree where {bold(target_branch)} is checked out")
+                self._git.chdir(target_worktree_root_dir)
 
     def traverse(
             self,
@@ -140,10 +134,10 @@ def traverse(
 
         # Store the initial directory for later restoration
         initial_branch = nearest_remaining_branch = self._git.get_current_branch()
-        initial_worktree_root = self._git.get_root_dir()
+        initial_worktree_root = self._git.get_current_worktree_root_dir()
 
         # Fetch worktrees once at the start to avoid repeated git worktree list calls
-        self.__worktrees_cache: Dict[LocalBranchShortName, str] = self._git.get_worktrees()
+        self.__worktree_root_dir_for_branch: Dict[LocalBranchShortName, str] = self._git.get_worktree_root_dirs_by_branch()
 
         try:
             if opt_start_from == TraverseStartFrom.ROOT:
@@ -502,7 +496,7 @@ def traverse(
         finally:
             # Warn if the initial directory doesn't correspond to the final checked out branch's worktree
             final_branch = self._git.get_current_branch()
-            final_worktree_path = self.__worktrees_cache.get(final_branch)
+            final_worktree_path = self.__worktree_root_dir_for_branch.get(final_branch)
             if final_worktree_path and initial_worktree_root != final_worktree_path:
                 # Final branch is checked out in a worktree different from where we started
                 warn(

git_machete/client/with_code_hosting.py

@@ -293,7 +293,7 @@ def create_pull_request(
         fork_point = self.fork_point(head, use_overrides=True)
         commits: List[GitLogEntry] = self._git.get_commits_between(fork_point, head)
 
-        pr_title_file_path = self._git.get_main_git_subpath('info', 'title')
+        pr_title_file_path = self._git.get_main_worktree_git_subpath('info', 'title')
         is_pr_title_file = os.path.isfile(pr_title_file_path)
         if opt_title:
             title = opt_title
@@ -310,11 +310,11 @@ def create_pull_request(
         if force_description_from_commit_message:
             description = self._git.get_commit_data(commits[0].hash, GitFormatPatterns.MESSAGE_BODY) if commits else ''
         else:
-            machete_description_path = self._git.get_main_git_subpath('info', 'description')
+            machete_description_path = self._git.get_main_worktree_git_subpath('info', 'description')
             if os.path.isfile(machete_description_path):
                 description = slurp_file(machete_description_path)
             else:
-                code_hosting_description_paths = [os.path.join(self._git.get_root_dir(), *path) for path in spec.pr_description_paths]
+                code_hosting_description_paths = [os.path.join(self._git.get_current_worktree_root_dir(), *path) for path in spec.pr_description_paths]
                 existing = find_or_none(os.path.isfile, code_hosting_description_paths)
                 if existing:
                     description = slurp_file(existing)
@@ -345,7 +345,7 @@ def create_pull_request(
                 self.code_hosting_client.set_description_of_pull_request(pr.number, new_description)
                 print(fmt(ok_str))
 
-        milestone_path: str = self._git.get_main_git_subpath('info', 'milestone')
+        milestone_path: str = self._git.get_main_worktree_git_subpath('info', 'milestone')
         if os.path.isfile(milestone_path):
             milestone = slurp_file(milestone_path).strip()
         else:
@@ -360,7 +360,7 @@ def create_pull_request(
             self.code_hosting_client.add_assignees_to_pull_request(pr.number, [current_user])
             print(fmt(ok_str))
 
-        reviewers_path = self._git.get_main_git_subpath('info', 'reviewers')
+        reviewers_path = self._git.get_main_worktree_git_subpath('info', 'reviewers')
         if os.path.isfile(reviewers_path):
             reviewers = utils.get_non_empty_lines(slurp_file(reviewers_path))
         else: