Implement reactive branch dashboard

Author: kaste

core/interfaces/branch.py

@@ -1,13 +1,19 @@
+from contextlib import contextmanager
+from functools import partial
 import os
+import threading
 
+import sublime
 from sublime_plugin import WindowCommand
 
+from .status import distinct_until_state_changed
 from ...common import ui, util
 from ..commands import GsNavigate
 from ..commands.log import LogMixin
 from ..git_command import GitCommand
 from ..ui_mixins.quick_panel import show_remote_panel, show_branch_panel
 from ..ui_mixins.input_panel import show_single_line_input_panel
+from GitSavvy.core import store
 from GitSavvy.core.fns import filter_
 from GitSavvy.core.utils import flash
 from GitSavvy.core.runtime import on_worker
@@ -39,8 +45,24 @@
 
 MYPY = False
 if MYPY:
-    from typing import List, Optional
-    from GitSavvy.core.git_mixins.branches import Branch
+    from typing import Dict, List, Optional, TypedDict
+    from ..git_mixins.active_branch import Commit
+    from ..git_mixins.branches import Branch
+
+    BranchViewState = TypedDict(
+        "BranchViewState",
+        {
+            "git_root": str,
+            "long_status": str,
+            "branches": List[Branch],
+            "descriptions": Dict[str, str],
+            "remotes": Dict[str, str],
+            "recent_commits": List[Commit],
+            "show_remotes": bool,
+            "show_help": bool,
+        },
+        total=False
+    )
 
 
 class gs_show_branch(WindowCommand, GitCommand):
@@ -62,8 +84,6 @@ class BranchInterface(ui.Interface, GitCommand):
     interface_type = "branch"
     syntax_file = "Packages/GitSavvy/syntax/branch.sublime-syntax"
 
-    show_remotes = None
-
     template = """\
 
       ROOT:    {git_root}
@@ -105,18 +125,80 @@ class BranchInterface(ui.Interface, GitCommand):
       REMOTE ({remote_name}):
     {remote_branch_list}"""
 
+    def __init__(self, *args, **kwargs):
+        self._lock = threading.Lock()
+        self.state = {
+            'git_root': '',
+            'long_status': '',
+            'recent_commits': [],
+            'branches': [],
+            'descriptions': {},
+            'remotes': {},
+            'show_remotes': self.savvy_settings.get("show_remotes_in_branch_dashboard"),
+            'show_help': True,
+        }  # type: BranchViewState
+        super().__init__(*args, **kwargs)
+
     def title(self):
         return "BRANCHES: {}".format(os.path.basename(self.repo_path))
 
-    def pre_render(self):
+    def refresh_view_state(self):
         sort_by_recent = self.savvy_settings.get("sort_by_recent_in_branch_dashboard")
-        self._branches = self.get_branches(sort_by_recent=sort_by_recent)
-        self.descriptions = self.fetch_branch_description_subjects()
-        if self.show_remotes is None:
-            self.show_remotes = self.savvy_settings.get("show_remotes_in_branch_dashboard")
-        self.remotes = self.get_remotes() if self.show_remotes else {}
+        for thunk in (
+            lambda: {'recent_commits': self.get_latest_commits()},
+            lambda: {
+                'branches': self.get_branches(sort_by_recent=sort_by_recent),
+                'descriptions': self.fetch_branch_description_subjects(),
+            },
+            lambda: {'remotes': self.get_remotes()},
+        ):
+            sublime.set_timeout_async(
+                partial(self.update_state, thunk, then=self.just_render)
+            )
+
+        self.view.run_command("gs_update_status")
+        # These are cheap to compute, so we just do it!
+        state = store.current_state(self.repo_path)
+        status = state.get("status")
+        if status:
+            self.update_state(status._asdict())
+        self.update_state({
+            'git_root': self.short_repo_path,
+            'branches': state.get("branches", []),
+            'recent_commits': state.get("recent_commits", []),
+            'show_help': not self.view.settings().get("git_savvy.help_hidden"),
+        })
+
+    def update_state(self, data, then=None):
+        """Update internal view state and maybe invoke a callback.
+
+        `data` can be a mapping or a callable ("thunk") which returns
+        a mapping.
+
+        Note: We invoke the "sink" without any arguments. TBC.
+        """
+        if callable(data):
+            data = data()
+
+        with self._lock:
+            self.state.update(data)
+
+        if callable(then):
+            then()
 
     def render(self):
+        """Refresh view state and render."""
+        self.refresh_view_state()
+        self.just_render()
+
+    @distinct_until_state_changed
+    def just_render(self):
+        content, regions = self._render_template()
+        with self.keep_cursor_on_something():
+            self.draw(self.title(), content, regions)
+
+    @contextmanager
+    def keep_cursor_on_something(self):
         def cursor_is_on_active_branch():
             sel = self.view.sel()
             return (
@@ -128,29 +210,50 @@ def cursor_is_on_active_branch():
             )
 
         cursor_was_on_active_branch = cursor_is_on_active_branch()
-        super().render()
+        yield
         if cursor_was_on_active_branch and not cursor_is_on_active_branch():
             self.view.run_command("gs_branches_navigate_to_active_branch")
 
+    def on_status_update(self, _repo_path, state):
+        try:
+            new_state = state["status"]._asdict()
+        except KeyError:
+            new_state = {}
+        new_state["branches"] = state.get("branches")
+        new_state["recent_commits"] = state.get("recent_commits")
+        self.update_state(new_state, then=self.just_render)
+
+    def on_create(self):
+        self._unsubscribe = store.subscribe(
+            self.repo_path, {"status", "branches", "recent_commits"}, self.on_status_update
+        )
+
+    def on_close(self):
+        self._unsubscribe()
+
     def on_new_dashboard(self):
         self.view.run_command("gs_branches_navigate_to_active_branch")
 
     @ui.section("branch_status")
     def render_branch_status(self):
-        return self.get_working_dir_status().long_status
+        return self.state['long_status']
 
     @ui.section("git_root")
     def render_git_root(self):
-        return self.short_repo_path
+        return self.state['git_root']
 
     @ui.section("head")
     def render_head(self):
-        return self.get_latest_commit_msg_for_head()
+        recent_commits = self.state['recent_commits']
+        if not recent_commits:
+            return "No commits yet."
+
+        return "{0.hash} {0.message}".format(recent_commits[0])
 
     @ui.section("branch_list")
     def render_branch_list(self):
         # type: () -> str
-        branches = [branch for branch in self._branches if not branch.is_remote]
+        branches = [branch for branch in self.state["branches"] if not branch.is_remote]
         return self._render_branch_list(None, branches)
 
     def _render_branch_list(self, remote_name, branches):
@@ -161,7 +264,7 @@ def _render_branch_list(self, remote_name, branches):
                 indicator="▸" if branch.active else " ",
                 hash=branch.commit_hash,
                 name=branch.canonical_name[remote_name_l:],
-                description=(" " + self.descriptions.get(branch.canonical_name, "")).rstrip(),
+                description=(" " + self.state["descriptions"].get(branch.canonical_name, "")).rstrip(),
                 tracking=(" ({branch}{status})".format(
                     branch=branch.upstream.canonical_name,
                     status=", " + branch.upstream.status if branch.upstream.status else ""
@@ -172,26 +275,25 @@ def _render_branch_list(self, remote_name, branches):
     @ui.section("remotes")
     def render_remotes(self):
         return (self.render_remotes_on()
-                if self.show_remotes else
+                if self.state["show_remotes"] else
                 self.render_remotes_off())
 
     @ui.section("help")
     def render_help(self):
-        help_hidden = self.view.settings().get("git_savvy.help_hidden")
-        if help_hidden:
+        show_help = self.state['show_help']
+        if not show_help:
             return ""
-        else:
-            return self.template_help
+        return self.template_help
 
     def render_remotes_off(self):
         return "\n\n  ** Press [e] to toggle display of remote branches. **\n"
 
     def render_remotes_on(self):
         output_tmpl = "\n"
         render_fns = []
-        remote_branches = [b for b in self._branches if b.is_remote]
+        remote_branches = [b for b in self.state["branches"] if b.is_remote]
 
-        for remote_name in self.remotes:
+        for remote_name in self.state["remotes"]:
             key = "branch_list_" + remote_name
             output_tmpl += "{" + key + "}\n"
             branches = [b for b in remote_branches if b.canonical_name.startswith(remote_name + "/")]
@@ -228,7 +330,7 @@ def get_selected_branches(self, ignore_current_branch=False):
         def select_branch(remote_name, branch_name):
             # type: (str, str) -> Branch
             canonical_name = "/".join(filter_((remote_name, branch_name)))
-            for branch in self.interface._branches:
+            for branch in self.interface.state["branches"]:
                 if branch.canonical_name == canonical_name:
                     return (
                         branch._replace(
@@ -260,7 +362,7 @@ def select_branch(remote_name, branch_name):
             )
         ] + [
             select_branch(remote_name, branch_name)
-            for remote_name in self.interface.remotes
+            for remote_name in self.interface.state["remotes"]
             for branch_name in ui.extract_by_selector(
                 self.view,
                 "meta.git-savvy.branches.branch.name",
@@ -525,9 +627,9 @@ class gs_branches_toggle_remotes(BranchInterfaceCommand):
 
     def run(self, edit, show=None):
         if show is None:
-            self.interface.show_remotes = not self.interface.show_remotes
+            self.interface.update_state({"show_remotes": not self.interface.state["show_remotes"]})
         else:
-            self.interface.show_remotes = show
+            self.interface.update_state({"show_remotes": show})
         self.interface.render()