Automatically inject state values into the render functions

Author: kaste

common/ui.py

@@ -1,6 +1,7 @@
 from contextlib import contextmanager
 from copy import deepcopy
 from functools import wraps
+import inspect
 import re
 from textwrap import dedent
 import threading
@@ -40,11 +41,12 @@
     T = TypeVar("T")
     T_state = TypeVar("T_state", bound=MutableMapping)
     SectionRegions = Dict[str, sublime.Region]
+    RenderFnReturnType = Union[str, Tuple[str, List["SectionFn"]]]
 
     class SectionFn(Protocol):
         key = ''  # type: str
 
-        def __call__(self) -> 'Union[str, Tuple[str, List[SectionFn]]]':
+        def __call__(self) -> RenderFnReturnType:
             pass
 
 
@@ -382,13 +384,45 @@ def _pick_subscribed_topics_from_store(self, state):
 
 
 def section(key):
-    # type: (str) -> Callable[[Callable[..., Union[str, Tuple[str, List[SectionFn]]]]], SectionFn]
+    # type: (str) -> Callable[[Callable[..., RenderFnReturnType]], SectionFn]
     def decorator(fn):
         fn.key = key
-        return fn
+        return inject_state()(fn)
     return decorator
 
 
+def inject_state():
+    def decorator(fn):
+        sig = inspect.signature(fn)
+        keys = ordered_positional_args(sig)
+        if "self" not in keys:
+            return fn
+
+        @wraps(fn)
+        def decorated(self, *args, **kwargs):
+            b = sig.bind_partial(self, *args, **kwargs)
+            given_args = b.arguments.keys()
+            try:
+                values = {key: self.state[key] for key in keys if key not in given_args}
+            except KeyError:
+                return ""
+            else:
+                kwargs.update(b.arguments)
+                kwargs.update(values)
+                return fn(**kwargs)
+        return decorated
+    return decorator
+
+
+def ordered_positional_args(sig):
+    # type: (inspect.Signature) -> List[str]
+    return [
+        name
+        for name, parameter in sig.parameters.items()
+        if parameter.default is inspect.Parameter.empty
+    ]
+
+
 def indent_by_2(text):
     return "\n".join(line[2:] for line in text.split("\n"))
 

core/interfaces/branch.py

@@ -167,16 +167,15 @@ def cursor_is_on_active_branch():
             self.view.run_command("gs_branches_navigate_to_active_branch")
 
     @ui.section("branch_status")
-    def render_branch_status(self):
-        return self.state['long_status']
+    def render_branch_status(self, long_status):
+        return long_status
 
     @ui.section("git_root")
-    def render_git_root(self):
-        return self.state['git_root']
+    def render_git_root(self, git_root):
+        return git_root
 
     @ui.section("head")
-    def render_head(self):
-        recent_commits = self.state['recent_commits']
+    def render_head(self, recent_commits):
         if recent_commits is NullRecentCommits:
             return ""
         if not recent_commits:
@@ -185,22 +184,22 @@ def render_head(self):
         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.state["branches"] if not branch.is_remote]
-        if self.state["sort_by_recent"]:
-            branches = sorted(branches, key=lambda branch: -branch.committerdate)
-        return self._render_branch_list(None, branches)
-
-    def _render_branch_list(self, remote_name, branches):
-        # type: (Optional[str], List[Branch]) -> str
-        remote_name_l = len(remote_name + "/") if remote_name else 0
+    def render_branch_list(self, branches, sort_by_recent, descriptions):
+        # type: (List[Branch], bool, Dict[str, str]) -> str
+        local_branches = [branch for branch in branches if not branch.is_remote]
+        if sort_by_recent:
+            local_branches = sorted(local_branches, key=lambda branch: -branch.committerdate)
+        return self._render_branch_list(None, local_branches, descriptions)
+
+    def _render_branch_list(self, remote_name, branches, descriptions):
+        # type: (Optional[str], List[Branch], Dict[str, str]) -> str
+        remote_name_length = len(remote_name + "/") if remote_name else 0
         return "\n".join(
             "  {indicator} {hash:.7} {name}{tracking}{description}".format(
                 indicator="▸" if branch.active else " ",
                 hash=branch.commit_hash,
-                name=branch.canonical_name[remote_name_l:],
-                description=(" " + self.state["descriptions"].get(branch.canonical_name, "")).rstrip(),
+                name=branch.canonical_name[remote_name_length:],
+                description=(" " + descriptions.get(branch.canonical_name, "")).rstrip(),
                 tracking=(" ({branch}{status})".format(
                     branch=branch.upstream.canonical_name,
                     status=", " + branch.upstream.status if branch.upstream.status else ""
@@ -209,29 +208,29 @@ def _render_branch_list(self, remote_name, branches):
         )
 
     @ui.section("remotes")
-    def render_remotes(self):
+    def render_remotes(self, show_remotes):
         return (self.render_remotes_on()
-                if self.state["show_remotes"] else
+                if show_remotes else
                 self.render_remotes_off())
 
     @ui.section("help")
-    def render_help(self):
-        show_help = self.state['show_help']
+    def render_help(self, show_help):
         if not show_help:
             return ""
         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):
+    @ui.inject_state()
+    def render_remotes_on(self, branches, sort_by_recent, remotes):
         output_tmpl = "\n"
         render_fns = []
-        remote_branches = [b for b in self.state["branches"] if b.is_remote]
-        if self.state["sort_by_recent"]:
+        remote_branches = [b for b in branches if b.is_remote]
+        if sort_by_recent:
             remote_branches = sorted(remote_branches, key=lambda branch: -branch.committerdate)
 
-        for remote_name in self.state["remotes"]:
+        for remote_name in remotes:
             key = "branch_list_" + remote_name
             output_tmpl += "{" + key + "}\n"
             branches = [b for b in remote_branches if b.canonical_name.startswith(remote_name + "/")]
@@ -240,7 +239,7 @@ def render_remotes_on(self):
             def render(remote_name=remote_name, branches=branches):
                 return self.template_remote.format(
                     remote_name=remote_name,
-                    remote_branch_list=self._render_branch_list(remote_name, branches)
+                    remote_branch_list=self._render_branch_list(remote_name, branches, {})
                 )
 
             render_fns.append(render)

core/interfaces/status.py

@@ -249,31 +249,30 @@ def after_view_creation(self, view):
         view.settings().set("result_base_dir", self.repo_path)
 
     @ui.section("branch_status")
-    def render_branch_status(self):
-        return self.state['long_status']
+    def render_branch_status(self, long_status):
+        return long_status
 
     @ui.section("git_root")
-    def render_git_root(self):
-        return self.state['git_root']
+    def render_git_root(self, git_root):
+        return git_root
 
     @ui.section("head")
-    def render_head(self):
-        # type: () -> str
-        recent_commits = self.state['recent_commits']
+    def render_head(self, recent_commits, head, branches):
+        # type: (List[Commit], HeadState, List[Branch]) -> str
         if recent_commits is NullRecentCommits:
             return ""
         if not recent_commits:
             return "No commits yet."
 
-        current_upstream = self.state['head'].remote
-        branches = self.state['branches']
+        current_upstream = head.remote
+        branches = branches
         return "\n           ".join(
             format_and_limit(recent_commits, ITEMS_IN_THE_RECENT_LIST, current_upstream, branches)
         )
 
     @ui.section("staged_files")
-    def render_staged_files(self):
-        staged_files = self.state['status'].staged_files
+    def render_staged_files(self, status):
+        staged_files = status.staged_files
         if not staged_files:
             return ""
 
@@ -289,8 +288,8 @@ def get_path(file_status):
         ))
 
     @ui.section("unstaged_files")
-    def render_unstaged_files(self):
-        unstaged_files = self.state['status'].unstaged_files
+    def render_unstaged_files(self, status):
+        unstaged_files = status.unstaged_files
         if not unstaged_files:
             return ""
 
@@ -300,47 +299,44 @@ def render_unstaged_files(self):
         ))
 
     @ui.section("untracked_files")
-    def render_untracked_files(self):
-        untracked_files = self.state['status'].untracked_files
+    def render_untracked_files(self, status):
+        untracked_files = status.untracked_files
         if not untracked_files:
             return ""
 
         return self.template_untracked.format(
             "\n".join("    " + f.path for f in untracked_files))
 
     @ui.section("merge_conflicts")
-    def render_merge_conflicts(self):
-        merge_conflicts = self.state['status'].merge_conflicts
+    def render_merge_conflicts(self, status):
+        merge_conflicts = status.merge_conflicts
         if not merge_conflicts:
             return ""
         return self.template_merge_conflicts.format(
             "\n".join("    " + f.path for f in merge_conflicts))
 
     @ui.section("conflicts_bindings")
-    def render_conflicts_bindings(self):
-        return self.conflicts_keybindings if self.state['status'].merge_conflicts else ""
+    def render_conflicts_bindings(self, status):
+        return self.conflicts_keybindings if status.merge_conflicts else ""
 
     @ui.section("no_status_message")
-    def render_no_status_message(self):
-        status = self.state['status']
+    def render_no_status_message(self, status):
         return (
             "\n    Your working directory is clean.\n"
             if status is not NullWorkingDirState and status.clean
             else ""
         )
 
     @ui.section("stashes")
-    def render_stashes(self):
-        stash_list = self.state['stashes']
-        if not stash_list:
+    def render_stashes(self, stashes):
+        if not stashes:
             return ""
 
         return self.template_stashes.format("\n".join(
-            "    ({}) {}".format(stash.id, stash.description) for stash in stash_list))
+            "    ({}) {}".format(stash.id, stash.description) for stash in stashes))
 
     @ui.section("help")
-    def render_help(self):
-        show_help = self.state['show_help']
+    def render_help(self, show_help):
         if not show_help:
             return ""
 

core/interfaces/tags.py

@@ -157,16 +157,15 @@ def keep_cursor_on_something(self):
             self.view.run_command("gs_tags_navigate_tag")
 
     @ui.section("branch_status")
-    def render_branch_status(self):
-        return self.state['long_status']
+    def render_branch_status(self, long_status):
+        return long_status
 
     @ui.section("git_root")
-    def render_git_root(self):
-        return self.state['git_root']
+    def render_git_root(self, git_root):
+        return git_root
 
     @ui.section("head")
-    def render_head(self):
-        recent_commits = self.state['recent_commits']
+    def render_head(self, recent_commits):
         if recent_commits is NullRecentCommits:
             return ""
         if not recent_commits:
@@ -175,15 +174,13 @@ def render_head(self):
         return "{0.hash} {0.message}".format(recent_commits[0])
 
     @ui.section("local_tags")
-    def render_local_tags(self):
-        local_tags = self.state["local_tags"]
+    def render_local_tags(self, local_tags, max_items):
         if local_tags is NullTagList:
             return ""
         if not any(local_tags.all):
             return NO_LOCAL_TAGS_MESSAGE
 
         regular_tags, versions = local_tags
-        max_items = self.state["max_items"]
         return "\n{}\n".format(" " * 60).join(  # need some spaces on the separator line otherwise
                                                 # the syntax expects the remote section begins
             filter_((
@@ -207,17 +204,17 @@ def render_local_tags(self):
         )
 
     @ui.section("remote_tags")
-    def render_remote_tags(self):
-        if not self.state["remotes"]:
+    def render_remote_tags(self, remotes, show_remotes):
+        if not remotes:
             return "\n"
 
-        if not self.state["show_remotes"]:
+        if not show_remotes:
             return self.render_remote_tags_off()
 
         output_tmpl = "\n"
         render_fns = []
 
-        for remote_name in self.state["remotes"]:
+        for remote_name in remotes:
             tmpl_key = "remote_tags_list_" + remote_name
             output_tmpl += "{" + tmpl_key + "}\n"
 
@@ -230,8 +227,7 @@ def render_remote(remote_name=remote_name) -> str:
         return output_tmpl, render_fns
 
     @ui.section("help")
-    def render_help(self):
-        show_help = self.state['show_help']
+    def render_help(self, show_help):
         if not show_help:
             return ""
         return self.template_help