Compare commits
3 Commits
main
...
25f8098314
| Author | SHA1 | Date | |
|---|---|---|---|
|
25f8098314 | ||
|
|
ff820a09d7 | ||
|
|
dc11d4e688 |
@@ -3,46 +3,10 @@
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["c"], "command": "vdiff_action", "args": {"action": "commits"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["s"], "command": "vdiff_action", "args": {"action": "stage"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["u"], "command": "vdiff_action", "args": {"action": "unstage"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["S"], "command": "vdiff_action", "args": {"action": "stage_all"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["U"], "command": "vdiff_action", "args": {"action": "unstage_all"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["d"], "command": "vdiff_action", "args": {"action": "discard"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["o"], "command": "vdiff_action", "args": {"action": "open"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["enter"], "command": "vdiff_action", "args": {"action": "open"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["v"], "command": "vdiff_action", "args": {"action": "view"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["right"], "command": "vdiff_action", "args": {"action": "expand"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["left"], "command": "vdiff_action", "args": {"action": "collapse"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["z"], "command": "vdiff_action", "args": {"action": "fold_all"},
|
||||
{ "keys": ["b"], "command": "vdiff_action", "args": {"action": "branches"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["r"], "command": "vdiff_action", "args": {"action": "refresh"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["]"], "command": "vdiff_action", "args": {"action": "next_change"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["["], "command": "vdiff_action", "args": {"action": "prev_change"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["n"], "command": "vdiff_action", "args": {"action": "next_file"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["p"], "command": "vdiff_action", "args": {"action": "prev_file"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["j"], "command": "vdiff_action", "args": {"action": "line_down"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["k"], "command": "vdiff_action", "args": {"action": "line_up"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["C"], "command": "vdiff_action", "args": {"action": "commit"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["m"], "command": "vdiff_action", "args": {"action": "amend"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["?"], "command": "vdiff_action", "args": {"action": "help"},
|
||||
"context": [{"key": "setting.vdiff_view"}] },
|
||||
{ "keys": ["escape"], "command": "vdiff_action", "args": {"action": "close"},
|
||||
@@ -53,5 +17,69 @@
|
||||
{"key": "popup_visible", "operand": false},
|
||||
{"key": "auto_complete_visible", "operand": false},
|
||||
{"key": "num_selections", "operand": 1}
|
||||
] }
|
||||
] },
|
||||
|
||||
{ "keys": ["s"], "command": "vdiff_action", "args": {"action": "stage"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["u"], "command": "vdiff_action", "args": {"action": "unstage"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["S"], "command": "vdiff_action", "args": {"action": "stage_all"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["U"], "command": "vdiff_action", "args": {"action": "unstage_all"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["d"], "command": "vdiff_action", "args": {"action": "discard"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["o"], "command": "vdiff_action", "args": {"action": "open"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["enter"], "command": "vdiff_action", "args": {"action": "open"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["v"], "command": "vdiff_action", "args": {"action": "view"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["right"], "command": "vdiff_action", "args": {"action": "expand"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["left"], "command": "vdiff_action", "args": {"action": "collapse"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["z"], "command": "vdiff_action", "args": {"action": "fold_all"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["]"], "command": "vdiff_action", "args": {"action": "next_change"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["["], "command": "vdiff_action", "args": {"action": "prev_change"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["n"], "command": "vdiff_action", "args": {"action": "next_file"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["p"], "command": "vdiff_action", "args": {"action": "prev_file"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["j"], "command": "vdiff_action", "args": {"action": "line_down"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["k"], "command": "vdiff_action", "args": {"action": "line_up"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["C"], "command": "vdiff_action", "args": {"action": "commit"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
{ "keys": ["m"], "command": "vdiff_action", "args": {"action": "amend"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "diff"}] },
|
||||
|
||||
{ "keys": ["J"], "command": "vdiff_action", "args": {"action": "next_branch"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["K"], "command": "vdiff_action", "args": {"action": "prev_branch"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["j"], "command": "vdiff_action", "args": {"action": "next_commit"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["k"], "command": "vdiff_action", "args": {"action": "prev_commit"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["o"], "command": "vdiff_action", "args": {"action": "open_commit"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["v"], "command": "vdiff_action", "args": {"action": "open_commit"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["enter"], "command": "vdiff_action", "args": {"action": "checkout"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["shift+enter"], "command": "vdiff_action", "args": {"action": "checkout_detached"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["L"], "command": "vdiff_action", "args": {"action": "pull"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["P"], "command": "vdiff_action", "args": {"action": "push"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["F"], "command": "vdiff_action", "args": {"action": "fetch"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] },
|
||||
{ "keys": ["d"], "command": "vdiff_action", "args": {"action": "delete_branch"},
|
||||
"context": [{"key": "setting.vdiff_view"}, {"key": "vdiff_mode", "operand": "branches"}] }
|
||||
]
|
||||
|
||||
37
README.md
37
README.md
@@ -45,12 +45,15 @@ Use one method or the other, not both: an unpacked `Packages/vDiff` directory ov
|
||||
the list previews each file; Enter keeps it, Esc goes back to what was shown.
|
||||
- **vDiff: Recent Commits** – last N commits, then the files of the chosen commit. A key binding to
|
||||
`vdiff_commits` with `{"sha": "HEAD"}` skips the list and reviews the last commit directly.
|
||||
- **vDiff: Branches** – local branches and remotes on the left, the commits of the selected branch on
|
||||
the right; checkout, pull, push, fetch and delete from the keyboard.
|
||||
|
||||
## Keys inside the review view
|
||||
|
||||
| key | action |
|
||||
|---|---|
|
||||
| `f` / `c` | changed files / recent commits panel |
|
||||
| `b` | the branches view |
|
||||
| `s` / `u` / `d` | stage / unstage / discard the file (uncommitted mode); `s` then moves on to the next unstaged file |
|
||||
| `S` / `U` | stage all unstaged files / unstage all staged files |
|
||||
| `C` | commit the staged files, typing the message in an input panel |
|
||||
@@ -66,7 +69,39 @@ Use one method or the other, not both: an unpacked `Packages/vDiff` directory ov
|
||||
| `?` | show this key list in a popup |
|
||||
| Esc | close the view |
|
||||
|
||||
The header links do the same with the mouse. The all-files view shows five context lines around each change by default; configure this with `all_files_context` in `vDiff.sublime-settings`. The same file sets the background of deleted and inserted lines (`deleted_line_background`, `inserted_line_background`) and the colours of the all-files line-number column (`line_numbers_foreground`, `line_numbers_background`); left empty, they follow the colour scheme. Each all-files file heading shows the file's status letter (`s` when anything is staged, else `m`, `d`, `a`, `?` ...) before its -/+ counts, and takes its colours from `file_header_background`, `file_header_status_foreground`, `file_header_deleted_foreground` and `file_header_inserted_foreground`.
|
||||
The header links do the same with the mouse.
|
||||
|
||||
## Keys inside the branches view
|
||||
|
||||
`b` turns the review view into the branches view: local branches and remotes in the left column, the
|
||||
last N commits (`commits_count`) of the selected branch in the right one, each with its author, date,
|
||||
tags and diffstat. A local branch shows how it stands against its upstream on the right of its cell:
|
||||
`↑2` commits ahead, `↓1` behind, `gone` when the upstream was deleted, nothing when level or untracked.
|
||||
The right column starts with the working tree: how many files are staged and unstaged (a partially
|
||||
staged file counts in both) and their diffstat, or `No Changes`. The selected branch is the tinted cell;
|
||||
the caret marks a commit, or that entry.
|
||||
|
||||
| key | action |
|
||||
|---|---|
|
||||
| `J` / `K` | select the next / previous branch, local ones first, then each remote's |
|
||||
| `j` / `k` | move to the next / previous commit |
|
||||
| Enter | checkout the selected branch; a remote branch becomes a local branch of the same name tracking it (an existing one is reused) |
|
||||
| `shift+enter` | checkout a remote branch detached |
|
||||
| `L` | pull: `git pull` on the checked-out branch, a fast-forward from the upstream for any other local branch |
|
||||
| `P` | push to the upstream, or with `-u` to the branch's remote (origin by default) when it has none |
|
||||
| `F` | fetch all remotes and prune the branches they dropped |
|
||||
| `d` | delete the selected local branch, asking first (and again when it is not fully merged) |
|
||||
| `o` or `v` | review the commit under the caret, or the changed files when it is on the working-tree entry |
|
||||
| `f` / `c` | back to the changed files / recent commits; Esc in that panel returns here |
|
||||
| `r` / `b` | reload |
|
||||
| `?` | show this key list in a popup |
|
||||
| Esc | close the view |
|
||||
|
||||
Pull, push and fetch run without a terminal, so credentials must come from a credential helper or an
|
||||
ssh agent: git fails at once instead of waiting for a password. The selected branch takes its tint from
|
||||
`file_header_background`; the -/+ counts and tags use `file_header_deleted_foreground` and
|
||||
`file_header_inserted_foreground`, after the restart that loads their colour-scheme rules. The view reloads when it comes back into focus after a checkout, commit,
|
||||
fetch or branch change was made elsewhere. A remote whose name contains a slash is listed wrongly. The all-files view shows five context lines around each change by default; configure this with `all_files_context` in `vDiff.sublime-settings`. The same file sets the background of deleted and inserted lines (`deleted_line_background`, `inserted_line_background`) and the colours of the all-files line-number column (`line_numbers_foreground`, `line_numbers_background`); left empty, they follow the colour scheme. Each all-files file heading shows the file's status letter (`s` when anything is staged, else `m`, `d`, `a`, `?` ...) before its -/+ counts, and takes its colours from `file_header_background`, `file_header_status_foreground`, `file_header_deleted_foreground` and `file_header_inserted_foreground`.
|
||||
|
||||
## The channel
|
||||
|
||||
|
||||
3
TODO.txt
3
TODO.txt
@@ -6,8 +6,7 @@
|
||||
## New functionality
|
||||
- Add (commit) summary view - in one view just changes across all files with 5 lines before and after change?)
|
||||
|
||||
- Add pull and push action
|
||||
- Add tags into commits list (and branches?)
|
||||
- Add tags into commits list (the branches view shows them already)
|
||||
- Add stash action ..
|
||||
|
||||
|
||||
|
||||
3
main.py
3
main.py
@@ -1,4 +1,4 @@
|
||||
"""vDiff plugin entry point: review uncommitted changes and recent commits inside Sublime Text
|
||||
"""vDiff plugin entry point: review uncommitted changes, recent commits and branches inside Sublime Text
|
||||
|
||||
Sublime reloads a plugin only when this file changes, so save it after editing a submodule
|
||||
"""
|
||||
@@ -14,6 +14,7 @@ for _name in [n for n in sys.modules if n.startswith(__package__ + ".vdiff")]:
|
||||
# command and listener classes are imported for sublime's discovery
|
||||
from .vdiff.commands import (
|
||||
VdiffActionCommand,
|
||||
VdiffBranchesCommand,
|
||||
VdiffCommitsCommand,
|
||||
VdiffFilesCommand,
|
||||
restore_view,
|
||||
|
||||
@@ -23,3 +23,25 @@ def scheme_override_sandbox(tmp_path, monkeypatch):
|
||||
palette.reset()
|
||||
monkeypatch.setattr(state, "STATES", {})
|
||||
monkeypatch.setattr(sublime, "packages_path", lambda: str(tmp_path))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def rings(monkeypatch):
|
||||
"""Record visual bells instead of drawing them"""
|
||||
import sublime # noqa: F401 (the stub must be importable before vdiff.render)
|
||||
|
||||
from vdiff import render
|
||||
|
||||
bells = []
|
||||
monkeypatch.setattr(render, "flash", lambda view: bells.append(view))
|
||||
return bells
|
||||
|
||||
|
||||
def put_caret(view, row):
|
||||
"""Move the stub view's caret to the start of `row` (0 is the first row below the header)"""
|
||||
import sublime
|
||||
|
||||
from vdiff import render
|
||||
|
||||
view.sel().clear()
|
||||
view.sel().add(sublime.Region(render.index_point(view, row)))
|
||||
|
||||
@@ -70,6 +70,16 @@ def status_message(text):
|
||||
pass
|
||||
|
||||
|
||||
# what ok_cancel_dialog answers; a test flips it to model Cancel
|
||||
dialog_answer = True
|
||||
dialogs = []
|
||||
|
||||
|
||||
def ok_cancel_dialog(message, ok_title="", title=""):
|
||||
dialogs.append((message, ok_title))
|
||||
return dialog_answer
|
||||
|
||||
|
||||
def packages_path():
|
||||
return "/tmp/Packages"
|
||||
|
||||
@@ -146,6 +156,7 @@ class View:
|
||||
self.regions = {}
|
||||
self.syntax = None
|
||||
self.read_only = True
|
||||
self.changes = 0
|
||||
self.name_ = ""
|
||||
self.sel_ = []
|
||||
self.status = {}
|
||||
@@ -168,6 +179,10 @@ class View:
|
||||
|
||||
def replace(self, edit, region, text):
|
||||
self.text = self.text[: region.begin()] + text + self.text[region.end() :]
|
||||
self.changes += 1
|
||||
|
||||
def change_count(self):
|
||||
return self.changes
|
||||
|
||||
def run_command(self, name, args=None):
|
||||
if name == "vdiff_replace":
|
||||
@@ -252,6 +267,19 @@ class View:
|
||||
def em_width(self):
|
||||
return 8.0
|
||||
|
||||
def style(self):
|
||||
# the scheme's globals; no background here, so palette falls back as it did before this was stubbed
|
||||
return {"line_highlight": "#3b4350"}
|
||||
|
||||
def line(self, point):
|
||||
region = self.full_line(point)
|
||||
end = region.b - 1 if self.text[region.b - 1:region.b] == "\n" else region.b
|
||||
return Region(region.a, end)
|
||||
|
||||
def viewport_extent(self):
|
||||
# 100 columns at the stub's em width
|
||||
return (800.0, 600.0)
|
||||
|
||||
def extract_tokens_with_scopes(self, region):
|
||||
"""One token per run of word characters and one per run of anything else, scoped by its shape
|
||||
|
||||
|
||||
763
tests/test_branches.py
Normal file
763
tests/test_branches.py
Normal file
@@ -0,0 +1,763 @@
|
||||
import pytest
|
||||
|
||||
import sublime # the stub, via conftest
|
||||
|
||||
from conftest import put_caret # noqa: E402
|
||||
from test_render import header, with_loaded_override # noqa: E402
|
||||
from vdiff import branches, commands, git, listeners, palette, render, state
|
||||
|
||||
|
||||
def ref(name, remote=None, upstream=None, ahead=0, behind=0, gone=False, current=False, sha="abc1234", upstream_remote=""):
|
||||
"""A Ref; the upstream's remote is read off its name unless given (None for a local upstream)"""
|
||||
branch = name.partition("/")[2] if remote else name
|
||||
if upstream_remote == "":
|
||||
upstream_remote = upstream.partition("/")[0] if upstream else None
|
||||
return git.Ref(name, branch, remote, sha, upstream, ahead, behind, gone, current, upstream_remote)
|
||||
|
||||
|
||||
def commit(subject, tags=(), files=8, insertions=260, deletions=58, sha="1" * 40):
|
||||
return git.Commit(sha, sha[:7], "vtvrdik", "20.12.2025", subject, files, insertions, deletions, tuple(tags))
|
||||
|
||||
|
||||
REFS = [
|
||||
ref("feature"),
|
||||
ref("main", upstream="origin/main", ahead=1, current=True),
|
||||
ref("github/main", remote="github"),
|
||||
ref("origin/main", remote="origin"),
|
||||
]
|
||||
COMMITS = [
|
||||
commit("default file view mode and some colors now configurable in settings", tags=("v1.1.0",), sha="a" * 40),
|
||||
commit("next commit message", files=None, insertions=None, deletions=None, sha="b" * 40),
|
||||
]
|
||||
|
||||
|
||||
def make_state(refs=REFS, commits=COMMITS, selected="main", remotes=("origin", "github")):
|
||||
st = state.ViewState("/repo/vdiff")
|
||||
st.mode = state.MODE_BRANCHES
|
||||
st.branch_refs = list(refs)
|
||||
st.branch_remotes = list(remotes)
|
||||
st.branch_commits = list(commits)
|
||||
st.branch_ref = selected
|
||||
st.branch_head_sha = "abc1234"
|
||||
return st
|
||||
|
||||
|
||||
def rendered(st=None, live=False):
|
||||
"""A drawn branches view; `live` models a scheme that has picked up the override, as after a restart"""
|
||||
view = with_loaded_override(sublime.View()) if live else sublime.View()
|
||||
render.init_view(view)
|
||||
st = st or make_state()
|
||||
branches.render_branches(view, st)
|
||||
return view, st
|
||||
|
||||
|
||||
def rows(view):
|
||||
return view.text.split("\n")[1:]
|
||||
|
||||
|
||||
class Calls:
|
||||
"""Records the git helper calls an action makes; `answer` is what a worker returns"""
|
||||
|
||||
def __init__(self, monkeypatch, answer=None):
|
||||
self.calls = []
|
||||
self.answer = answer
|
||||
for name in ("checkout", "checkout_detached", "pull", "fetch_into", "push", "fetch_all", "delete_branch"):
|
||||
monkeypatch.setattr(branches.git, name, self._record(name))
|
||||
self.loads = record_loads(monkeypatch)
|
||||
|
||||
def _record(self, name):
|
||||
def call(*args, **kwargs):
|
||||
self.calls.append((name, args[1:], kwargs))
|
||||
if isinstance(self.answer, Exception):
|
||||
raise self.answer
|
||||
return self.answer
|
||||
|
||||
return call
|
||||
|
||||
|
||||
def record_loads(monkeypatch):
|
||||
"""Replace branches.load with a recorder of (branch, mode, message, keep_caret) per call"""
|
||||
loads = []
|
||||
|
||||
def fake_load(view, st, message=None, keep_caret=False):
|
||||
loads.append((st.branch_ref, st.mode, message, keep_caret))
|
||||
|
||||
monkeypatch.setattr(branches, "load", fake_load)
|
||||
return loads
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def calls(monkeypatch):
|
||||
return Calls(monkeypatch)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def loads(monkeypatch):
|
||||
return record_loads(monkeypatch)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def dialogs(monkeypatch):
|
||||
monkeypatch.setattr(sublime, "dialogs", [])
|
||||
monkeypatch.setattr(sublime, "dialog_answer", True)
|
||||
return sublime.dialogs
|
||||
|
||||
|
||||
# --- drawing ----------------------------------------------------------------
|
||||
|
||||
|
||||
def test_two_columns_are_laid_out_as_in_the_mockup():
|
||||
view, st = rendered()
|
||||
lines = rows(view)
|
||||
# the left column is as wide as its longest cell plus the padding; the gap follows it
|
||||
width = len(" feature") + branches.LEFT_PAD
|
||||
assert all(line[width:width + 2] == ("├─" if line.endswith("─") else "│ ") for line in lines)
|
||||
right = 100 - width - 2
|
||||
# the working tree comes first, five rows like a commit; nothing changed here
|
||||
assert lines[0] == f"{'BRANCHES':<{width}}│ No Changes"
|
||||
assert lines[1] == f"{' feature':<{width}}│ "
|
||||
# main is one commit ahead of its upstream: the count sits on the right edge of its cell
|
||||
assert lines[2] == f"{'* main':<{width - 3}}↑1 │ "
|
||||
assert lines[3] == f"{'REMOTES':<{width}}│ "
|
||||
assert lines[4] == f"{'origin':<{width}}├─" + "─" * right
|
||||
assert lines[5] == f"{' main':<{width}}│ default file view mode and some colors now configurable in settings"
|
||||
assert lines[6].startswith(f"{'github':<{width}}│ Author: vtvrdik")
|
||||
# the tag sits on the right edge of the author row
|
||||
assert lines[6].endswith("v1.1.0") and len(lines[6]) == width + 2 + right
|
||||
assert lines[7] == f"{' main':<{width}}│ Date: 20.12.2025"
|
||||
# the left column ran out, so the cells are blank
|
||||
assert lines[8] == f"{'':<{width}}│ Stats: 8 files changed -58 +260"
|
||||
assert lines[9] == f"{'':<{width}}├─" + "─" * right
|
||||
assert lines[10] == f"{'':<{width}}│ next commit message"
|
||||
assert lines[11].rstrip() == f"{'':<{width}}│ Author: vtvrdik"
|
||||
# no diffstat for a merge or an empty commit
|
||||
assert lines[13] == f"{'':<{width}}│ Stats: (no diffstat)"
|
||||
assert lines[14] == f"{'':<{width}}├─" + "─" * right
|
||||
assert len(lines) == 15
|
||||
assert view.syntax == "scope:text.plain"
|
||||
assert view.name_ == "⟐ branches"
|
||||
|
||||
|
||||
CHANGES = [
|
||||
git.FileChange("a.py", "M", False, 1, 1, None, unstaged=True),
|
||||
git.FileChange("b.txt", "M", True, 1, 0, None),
|
||||
git.FileChange("c.txt", "M", True, 2, 0, None, unstaged=True), # partially staged: counted on both sides
|
||||
git.FileChange("img.png", "M", True, None, None, None), # binary: no counts
|
||||
]
|
||||
|
||||
|
||||
def test_the_working_tree_entry_counts_the_staged_and_unstaged_files_and_their_diffstat():
|
||||
st = make_state()
|
||||
st.branch_changes = list(CHANGES)
|
||||
view, st = rendered(st)
|
||||
lines = rows(view)
|
||||
width = len(" feature") + branches.LEFT_PAD
|
||||
assert lines[0] == f"{'BRANCHES':<{width}}│ 3 staged files, 2 unstaged files"
|
||||
assert lines[1] == f"{' feature':<{width}}│ Stats: 4 files changed -1 +4"
|
||||
assert lines[2] == f"{'* main':<{width - 3}}↑1 │ " and lines[3] == f"{'REMOTES':<{width}}│ "
|
||||
assert lines[4].endswith("─" * 10) and lines[5].endswith("│ default file view mode and some colors now configurable in settings")
|
||||
# its counts are coloured like the commits', in row order
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_DEL][0]] == ["-1", "-58"]
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_INS][0]] == ["+4", "v1.1.0", "+260"]
|
||||
# the singular
|
||||
st.branch_changes = [CHANGES[0]]
|
||||
branches.render_branches(view, st)
|
||||
assert rows(view)[0] == f"{'BRANCHES':<{width}}│ 0 staged files, 1 unstaged file"
|
||||
st.branch_changes = [CHANGES[1]]
|
||||
branches.render_branches(view, st)
|
||||
assert rows(view)[0] == f"{'BRANCHES':<{width}}│ 1 staged file, 0 unstaged files"
|
||||
|
||||
|
||||
def test_local_branches_show_their_standing_against_the_upstream():
|
||||
refs = [ref("level", upstream="origin/level"), ref("ahead", upstream="origin/ahead", ahead=3, current=True),
|
||||
ref("both", upstream="origin/both", ahead=12, behind=4), ref("lost", upstream="origin/lost", gone=True),
|
||||
ref("untracked"), ref("origin/level", remote="origin")]
|
||||
view, st = rendered(make_state(refs=refs, selected="ahead", remotes=("origin",)))
|
||||
width = len(" both ↑12 ↓4") + branches.LEFT_PAD
|
||||
cells = [line[:width] for line in rows(view)]
|
||||
# in the listing's order; level and untracked branches carry nothing, nor do remote ones
|
||||
assert cells[1:6] == [f"{' level':<{width}}", f"{'* ahead':<{width - 3}}↑3 ", f"{' both':<{width - 7}}↑12 ↓4 ",
|
||||
f"{' lost':<{width - 5}}gone ", f"{' untracked':<{width}}"]
|
||||
assert cells[7] == f"{'origin':<{width}}" and cells[8] == f"{' level':<{width}}"
|
||||
# ahead is green, behind and gone red; the selected branch's standing is painted apart, on its background
|
||||
def painted(key):
|
||||
"""The coloured texts under a key"""
|
||||
return [view.text[r.a:r.b] for r in view.regions[key][0]]
|
||||
|
||||
assert painted(render.KEY_BRANCH_STANDING_INS) == ["↑12"] and painted(render.KEY_BRANCH_STANDING_DEL) == ["↓4", "gone"]
|
||||
assert painted(render.KEY_BRANCH_SEL_INS) == ["↑3"] and painted(render.KEY_BRANCH_SEL_DEL) == []
|
||||
# moving the selection moves the standing between the keys
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == "both"
|
||||
assert painted(render.KEY_BRANCH_STANDING_INS) == ["↑3"] and painted(render.KEY_BRANCH_STANDING_DEL) == ["gone"]
|
||||
assert painted(render.KEY_BRANCH_SEL_INS) == ["↑12"] and painted(render.KEY_BRANCH_SEL_DEL) == ["↓4"]
|
||||
# a long name gives way to its counts, never the other way round
|
||||
long = ref("feature/" + "x" * 60, upstream="origin/x", behind=2)
|
||||
view, st = rendered(make_state(refs=[ref("main", current=True), long], selected="main"))
|
||||
cell = rows(view)[2][:branches.LEFT_MAX]
|
||||
assert cell.endswith("↓2 ") and "…" in cell and len(cell) == branches.LEFT_MAX
|
||||
|
||||
|
||||
def test_rows_know_their_branch_and_commit():
|
||||
view, st = rendered()
|
||||
# item 0 is the working tree, the commits follow from 1
|
||||
assert [(r.ref and r.ref.name, r.commit) for r in st.branch_rows] == [
|
||||
(None, 0), ("feature", 0), ("main", 0), (None, 0), (None, 0),
|
||||
("origin/main", 1), (None, 1), ("github/main", 1), (None, 1), (None, 1),
|
||||
(None, 2), (None, 2), (None, 2), (None, 2), (None, 2),
|
||||
]
|
||||
|
||||
|
||||
def test_a_remote_without_fetched_branches_keeps_its_row():
|
||||
view, st = rendered(make_state(refs=[ref("main", current=True)], remotes=("origin", "gitea")))
|
||||
names = [line[:st.branch_width].rstrip() for line in rows(view)]
|
||||
assert names[:5] == ["BRANCHES", "* main", "REMOTES", "origin", "gitea"]
|
||||
|
||||
|
||||
def test_long_branch_names_are_clipped_at_the_cap():
|
||||
long = "feature/" + "x" * 60
|
||||
view, st = rendered(make_state(refs=[ref("main", current=True), ref(long)], selected="main"))
|
||||
width = branches.LEFT_MAX
|
||||
assert rows(view)[2].startswith(f"{' ' + long[:width - 4]}…" + " │ ") or rows(view)[2][width:width + 2] == "│ "
|
||||
assert rows(view)[2][:width].rstrip().endswith("…")
|
||||
|
||||
|
||||
def test_selection_headings_tags_and_counts_are_painted():
|
||||
view, st = rendered()
|
||||
width = len(" feature") + branches.LEFT_PAD
|
||||
starts = render._row_starts_for_text(rows(view))
|
||||
selected, scope, _, _ = view.regions[render.KEY_BRANCH_SEL]
|
||||
assert selected == [sublime.Region(starts[2], starts[2] + width)]
|
||||
assert scope == render._file_header_scope(view)
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_DEL][0]] == ["-58"]
|
||||
# the tags are green like the insertions, in row order; main's ↑1 sits on the selected row
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_INS][0]] == ["v1.1.0", "+260"]
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_SEL_INS][0]] == ["↑1"]
|
||||
assert view.regions[render.KEY_BRANCH_STANDING_INS][0] == []
|
||||
# filled regions, since only those take the scope's text colour; the scheme's tint stands in until the
|
||||
# override's red/green-on-background rules are live, after which the text is red / green on the editor
|
||||
# background, or on the heading background along the selected row so its tint runs through the standing
|
||||
assert not view.regions[render.KEY_BRANCH_DEL][3] & sublime.DRAW_NO_FILL
|
||||
assert view.regions[render.KEY_BRANCH_DEL][1] == palette.SCOPE_DEL
|
||||
assert view.regions[render.KEY_BRANCH_INS][1] == palette.SCOPE_INS
|
||||
assert view.regions[render.KEY_BRANCH_SEL_INS][1] == palette.SCOPE_INS
|
||||
live, _ = rendered(live=True)
|
||||
assert live.regions[render.KEY_BRANCH_DEL][1] == palette.SCOPE_TEXT_DEL
|
||||
assert live.regions[render.KEY_BRANCH_INS][1] == palette.SCOPE_TEXT_INS
|
||||
assert live.regions[render.KEY_BRANCH_STANDING_DEL][1] == palette.SCOPE_TEXT_DEL
|
||||
assert live.regions[render.KEY_BRANCH_SEL_DEL][1] == palette.SCOPE_FILE_DEL_COUNT
|
||||
assert live.regions[render.KEY_BRANCH_SEL_INS][1] == palette.SCOPE_FILE_INS_COUNT
|
||||
|
||||
|
||||
def test_caret_starts_on_the_working_tree_entry_and_stays_on_its_item_across_a_refresh():
|
||||
view, st = rendered()
|
||||
assert view.sel()[0].a == render.index_point(view, 0) and st.branch_rows[0].commit == branches.WORKTREE
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == branches.ROWS_PER_COMMIT
|
||||
branches.render_branches(view, st, keep_caret=True)
|
||||
assert render.caret_index(view) == branches.ROWS_PER_COMMIT
|
||||
# a plain redraw goes back to the top
|
||||
branches.render_branches(view, st)
|
||||
assert render.caret_index(view) == 0
|
||||
|
||||
|
||||
def test_no_commits_and_no_branches_still_draw():
|
||||
view, st = rendered(make_state(refs=[], commits=[], selected=None, remotes=()))
|
||||
rule = "─" * (100 - len("BRANCHES │ "))
|
||||
assert rows(view) == ["BRANCHES │ No Changes", "REMOTES │ ", " │ ", " │ ", " ├─" + rule,
|
||||
" │ (no commits)"]
|
||||
# the one item to step through is the working tree
|
||||
assert view.sel()[0].a == render.index_point(view, 0)
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 0
|
||||
assert view.regions[render.KEY_BRANCH_SEL][0] == []
|
||||
assert "no branch selected" in header(view)
|
||||
|
||||
|
||||
def test_render_sets_the_mode_and_persists_the_branch():
|
||||
view, st = rendered()
|
||||
assert view.settings().get(state.MODE_SETTING) == "branches"
|
||||
assert view.settings().get(state.VIEW_DATA) == {"repo": "/repo/vdiff", "sha": None, "mode": "branches", "ref": "main"}
|
||||
assert view.status[render.STATUS_KEY] == render.key_hints("branches")
|
||||
assert st.fingerprint == ((), (None,)) # no ref paths and no index outside a repository
|
||||
# a diff render switches back
|
||||
st.change = git.FileChange("x.py", "M", False, 1, 1, None)
|
||||
render.render_message(view, st, "nothing")
|
||||
assert view.settings().get(state.MODE_SETTING) == "diff"
|
||||
assert "mode" not in view.settings().get(state.VIEW_DATA)
|
||||
assert view.status[render.STATUS_KEY] == render.key_hints()
|
||||
assert render.KEY_BRANCH_SEL not in view.regions
|
||||
|
||||
|
||||
def test_an_unchanged_header_is_not_redrawn():
|
||||
view, st = rendered()
|
||||
first = view.phantoms[render.PHANTOM_KEY][0]
|
||||
# the same header over the same text keeps the phantom in place
|
||||
render._header(view, st, st.header[0])
|
||||
assert view.phantoms[render.PHANTOM_KEY] == [first]
|
||||
# new text may have dropped the phantom, so it is drawn again even for the same header
|
||||
branches.render_branches(view, st, keep_caret=True)
|
||||
assert view.phantoms[render.PHANTOM_KEY][0] is not first and len(view.phantoms[render.PHANTOM_KEY]) == 1
|
||||
|
||||
|
||||
def test_header_shows_head_upstream_and_the_links_of_the_selected_kind():
|
||||
view, st = rendered()
|
||||
text = header(view)
|
||||
assert "Branches · vdiff" in text and ">main<" in text and "on <span" in text
|
||||
# the standing as the cell shows it: a zero count is left out
|
||||
assert "→ origin/main" in text and '<span class="ins">↑1</span>' in text and "↓0" not in text
|
||||
st.branch_refs[1] = ref("main", upstream="origin/main", behind=2, current=True)
|
||||
branches.render_branches(view, st)
|
||||
assert '<span class="del">↓2</span>' in header(view) and "↑0" not in header(view)
|
||||
st.branch_refs[1] = ref("main", upstream="origin/main", current=True)
|
||||
branches.render_branches(view, st)
|
||||
assert "up to date" in header(view)
|
||||
st.branch_refs[1] = REFS[1]
|
||||
branches.render_branches(view, st)
|
||||
for link in ("checkout", "pull", "push", "fetch", "delete_branch", "files", "commits", "branches", "help"):
|
||||
assert f'href="{link}"' in text
|
||||
assert 'href="checkout_detached"' not in text
|
||||
|
||||
st.branch_ref = "origin/main"
|
||||
branches.render_branches(view, st)
|
||||
text = header(view)
|
||||
assert "remote branch of origin" in text and 'href="checkout_detached"' in text
|
||||
assert 'href="delete_branch"' not in text and 'href="pull"' not in text
|
||||
|
||||
st.branch_ref = "feature"
|
||||
st.branch_refs[1] = ref("main", upstream="origin/main", ahead=1) # nothing checked out: detached
|
||||
branches.render_branches(view, st)
|
||||
text = header(view)
|
||||
assert "detached at" in text and "abc1234" in text and "→" not in text
|
||||
st.branch_head_sha = ""
|
||||
branches.render_branches(view, st)
|
||||
assert "no commits" in header(view)
|
||||
|
||||
st.branch_refs[0] = ref("feature", upstream="origin/feature", gone=True)
|
||||
branches.render_branches(view, st)
|
||||
assert ">gone<" in header(view)
|
||||
|
||||
|
||||
# --- navigation -------------------------------------------------------------
|
||||
|
||||
|
||||
def test_j_and_k_step_commits_and_ring_at_the_ends(rings):
|
||||
view, st = rendered()
|
||||
# the working tree, then the two commits
|
||||
branches.ACTIONS["prev_commit"](view, None, st)
|
||||
assert len(rings) == 1 and render.caret_index(view) == 0
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 5
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 10
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert len(rings) == 2 and render.caret_index(view) == 10
|
||||
branches.ACTIONS["prev_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 5
|
||||
# off the items (the caret moved by the arrows onto a left-column-only row): k goes to the last, j to the first
|
||||
view, st = rendered(make_state(refs=REFS + [ref("x"), ref("y"), ref("z")], commits=COMMITS[:1]))
|
||||
assert st.branch_rows[10].commit == -1
|
||||
put_caret(view, 10)
|
||||
branches.ACTIONS["prev_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 5
|
||||
put_caret(view, 10)
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 0
|
||||
|
||||
|
||||
def test_J_and_K_select_branches_skipping_headings_and_reload_the_log(monkeypatch, rings):
|
||||
logged = []
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: logged.append(name) or [COMMITS[1]])
|
||||
view, st = rendered()
|
||||
assert st.branch_ref == "main"
|
||||
branches.ACTIONS["prev_branch"](view, None, st)
|
||||
assert st.branch_ref == "feature" and logged == ["feature"]
|
||||
branches.ACTIONS["prev_branch"](view, None, st)
|
||||
assert st.branch_ref == "feature" and len(rings) == 1
|
||||
for expected in ("main", "github/main", "origin/main"):
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == expected
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == "origin/main" and len(rings) == 2
|
||||
# the stub runs the worker at once, so the log was redrawn with the new selection
|
||||
assert rows(view)[5].endswith("│ next commit message")
|
||||
selected = view.regions[render.KEY_BRANCH_SEL][0]
|
||||
assert view.text[selected[0].a:selected[0].b].strip() == "main"
|
||||
# the caret went back to the working-tree entry
|
||||
assert render.caret_index(view) == 0 and st.branch_rows[0].commit == branches.WORKTREE
|
||||
|
||||
|
||||
def test_a_stale_log_is_dropped(monkeypatch):
|
||||
pending = []
|
||||
monkeypatch.setattr(branches, "run_async", lambda work, done: pending.append((work, done)))
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: [commit(name)])
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["prev_branch"](view, None, st) # feature
|
||||
branches.ACTIONS["next_branch"](view, None, st) # main
|
||||
assert [name for name in (st.branch_ref,)] == ["main"] and len(pending) == 2
|
||||
# the older answer lands first, but the token moved on
|
||||
work, done = pending[0]
|
||||
done(work())
|
||||
assert "│ feature" not in view.text
|
||||
work, done = pending[1]
|
||||
done(work())
|
||||
assert rows(view)[5].endswith("│ main")
|
||||
|
||||
|
||||
def test_load_lists_everything_and_picks_the_branch(monkeypatch):
|
||||
monkeypatch.setattr(branches.git, "head_sha", lambda repo: "abc1234")
|
||||
monkeypatch.setattr(branches.git, "ref_paths", lambda repo: ())
|
||||
monkeypatch.setattr(branches.git, "branches", lambda repo: list(REFS))
|
||||
monkeypatch.setattr(branches.git, "remotes", lambda repo: ["origin", "github"])
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: [commit(f"log of {name}")])
|
||||
monkeypatch.setattr(branches.git, "index_path", lambda repo: None)
|
||||
monkeypatch.setattr(branches.git, "changed_files", lambda repo: [CHANGES[2]])
|
||||
view = sublime.View()
|
||||
render.init_view(view)
|
||||
st = state.ViewState("/repo/vdiff")
|
||||
branches.load(view, st)
|
||||
# nothing wanted: the checked-out branch; the working tree above its log
|
||||
assert st.branch_ref == "main" and rows(view)[5].endswith("│ log of main")
|
||||
assert rows(view)[0].endswith("│ 1 staged file, 1 unstaged file") and rows(view)[1].endswith("│ Stats: 1 file changed -0 +2")
|
||||
assert st.branch_changes == [CHANGES[2]]
|
||||
assert st.branch_remotes == ["origin", "github"] and st.branch_head_sha == "abc1234"
|
||||
assert st.token == st.rendered_token
|
||||
# a wanted branch that vanished falls back the same way
|
||||
st.branch_ref = "deleted"
|
||||
branches.load(view, st)
|
||||
assert st.branch_ref == "main"
|
||||
st.branch_ref = "origin/main"
|
||||
branches.load(view, st)
|
||||
assert st.branch_ref == "origin/main" and rows(view)[5].endswith("│ log of origin/main")
|
||||
|
||||
|
||||
def test_pick_prefers_the_wanted_then_the_current_then_the_first_local_then_the_first():
|
||||
assert branches._pick(REFS, "origin/main").name == "origin/main"
|
||||
assert branches._pick(REFS, "gone").name == "main"
|
||||
detached = [ref("feature"), ref("zeta"), ref("origin/x", remote="origin")]
|
||||
assert branches._pick(detached, None).name == "feature"
|
||||
assert branches._pick([ref("origin/x", remote="origin")], None).name == "origin/x"
|
||||
assert branches._pick([], None) is None
|
||||
|
||||
|
||||
# --- actions ----------------------------------------------------------------
|
||||
|
||||
|
||||
def test_checkout_routes_local_current_and_remote_branches(calls):
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["checkout"](view, None, st)
|
||||
assert calls.calls == [] and calls.loads == [] # already on main
|
||||
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["checkout"](view, None, st)
|
||||
assert calls.calls[-1] == ("checkout", (REFS[0], ["feature", "main"]), {})
|
||||
assert calls.loads[-1] == ("feature", "branches", "checked out feature", False)
|
||||
|
||||
st.branch_ref = "github/main"
|
||||
branches.ACTIONS["checkout"](view, None, st)
|
||||
assert calls.calls[-1][1][0].name == "github/main"
|
||||
assert st.branch_ref == "main" # the local branch of that name is what got checked out
|
||||
|
||||
st.branch_ref = "origin/main"
|
||||
branches.ACTIONS["checkout_detached"](view, None, st)
|
||||
assert calls.calls[-1] == ("checkout_detached", ("origin/main",), {})
|
||||
assert calls.loads[-1][2] == "checked out origin/main detached"
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["checkout_detached"](view, None, st)
|
||||
assert calls.calls[-1][0] == "checkout_detached" and len(calls.calls) == 3 # refused for a local branch
|
||||
|
||||
|
||||
def test_pull_pulls_the_current_branch_and_fast_forwards_another(calls):
|
||||
view, st = rendered(make_state(refs=REFS + [ref("tracked", upstream="origin/tracked", behind=2)]))
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert calls.calls[-1] == ("pull", (), {}) and calls.loads[-1][2] == "pulled main"
|
||||
st.branch_ref = "tracked"
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert calls.calls[-1] == ("fetch_into", ("origin", "tracked", "tracked"), {})
|
||||
assert calls.loads[-1][2] == "fast-forwarded tracked to origin/tracked"
|
||||
# the upstream's own name on its remote, not the local one
|
||||
st.branch_refs.append(ref("foo", upstream="origin/bar", behind=1))
|
||||
st.branch_ref = "foo"
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert calls.calls[-1] == ("fetch_into", ("origin", "bar", "foo"), {})
|
||||
st.branch_refs.append(ref("local", upstream="main", upstream_remote=None, behind=1))
|
||||
for name in ("feature", "origin/main", "local"):
|
||||
st.branch_ref = name
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert len(calls.calls) == 3 # no upstream, a remote row and a local upstream: all refused
|
||||
|
||||
|
||||
def test_push_uses_the_upstream_or_sets_one_on_origin(calls):
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("origin", "main"), {"remote_branch": "main"}) and calls.loads[-1][2] == "pushed main to origin"
|
||||
# to the upstream itself when it is called differently there
|
||||
st.branch_refs.append(ref("foo", upstream="gitea/bar", ahead=2))
|
||||
st.branch_ref = "foo"
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("gitea", "foo"), {"remote_branch": "bar"})
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("origin", "feature"), {"set_upstream": True})
|
||||
# without origin the first remote takes it; without any, nothing happens; nor for a local upstream
|
||||
st.branch_remotes = ["gitea"]
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("gitea", "feature"), {"set_upstream": True})
|
||||
st.branch_remotes = []
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
st.branch_ref = "origin/main"
|
||||
st.branch_remotes = ["origin"]
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
st.branch_refs.append(ref("local", upstream="main", upstream_remote=None, ahead=1))
|
||||
st.branch_ref = "local"
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert len(calls.calls) == 4
|
||||
|
||||
|
||||
def test_fetch_fetches_everything_and_keeps_the_cursor(calls):
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["fetch"](view, None, st)
|
||||
assert calls.calls == [("fetch_all", (), {})] and calls.loads == [("main", "branches", "fetched all remotes", True)]
|
||||
|
||||
|
||||
def test_delete_asks_then_deletes_and_asks_again_for_an_unmerged_branch(calls, dialogs, monkeypatch):
|
||||
view, st = rendered()
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert dialogs == [("Delete the branch feature?", "Delete")]
|
||||
assert calls.calls == [("delete_branch", ("feature",), {})] and calls.loads == [("feature", "branches", "deleted feature", False)]
|
||||
|
||||
# not fully merged: a second question, then the forced deletion
|
||||
calls.answer = git.GitError("error: The branch 'feature' is not fully merged.\n", 1)
|
||||
del dialogs[:]
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert [d[1] for d in dialogs] == ["Delete", "Delete anyway"]
|
||||
assert calls.calls[-1] == ("delete_branch", ("feature",), {"force": True})
|
||||
|
||||
# Cancel on the first question does nothing; so does a remote or the checked-out branch
|
||||
monkeypatch.setattr(sublime, "dialog_answer", False)
|
||||
count = len(calls.calls)
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
st.branch_ref = "main"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
st.branch_ref = "origin/main"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert len(calls.calls) == count
|
||||
|
||||
|
||||
def test_other_git_errors_from_delete_still_reach_the_status_bar(calls, dialogs, monkeypatch):
|
||||
messages = []
|
||||
monkeypatch.setattr(branches, "status", lambda m: messages.append(m))
|
||||
monkeypatch.setattr("vdiff.utils.status", lambda m: messages.append(m))
|
||||
calls.answer = git.GitError("fatal: something else\n", 1)
|
||||
view, st = rendered()
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert messages[-1] == "fatal: something else" and calls.loads == []
|
||||
|
||||
|
||||
def test_o_reviews_the_commit_under_the_caret():
|
||||
view, st = rendered()
|
||||
window = sublime.Window()
|
||||
# the working-tree entry opens the files view, which itself stays put when there is nothing to list
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
assert window.commands == [("vdiff_files", None)]
|
||||
branches.ACTIONS["next_commit"](view, window, st)
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
branches.ACTIONS["next_commit"](view, window, st)
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
assert window.commands[1:] == [("vdiff_commits", {"sha": "a" * 40}), ("vdiff_commits", {"sha": "b" * 40})]
|
||||
# a row without an item (the left column outran the log) opens nothing
|
||||
view, st = rendered(make_state(refs=REFS + [ref("x"), ref("y"), ref("z")], commits=COMMITS[:1]))
|
||||
put_caret(view, 10)
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
assert len(window.commands) == 3
|
||||
|
||||
|
||||
def test_branch_actions_refuse_a_diff_view(calls):
|
||||
view, st = rendered()
|
||||
st.mode = state.MODE_DIFF
|
||||
for name in branches.ACTIONS:
|
||||
branches.ACTIONS[name](view, sublime.Window(), st)
|
||||
assert calls.calls == [] and calls.loads == []
|
||||
|
||||
|
||||
# --- wiring -----------------------------------------------------------------
|
||||
|
||||
|
||||
def test_b_opens_the_branches_command_and_refresh_reloads_in_place(loads):
|
||||
view, st = rendered()
|
||||
window = sublime.Window()
|
||||
commands.ACTIONS["branches"](view, window, st)
|
||||
assert window.commands == [("vdiff_branches", None)]
|
||||
commands.ACTIONS["refresh"](view, window, st)
|
||||
assert loads == [("main", "branches", None, True)]
|
||||
|
||||
|
||||
def test_restore_view_comes_back_in_branches_mode(loads, tmp_path):
|
||||
view = sublime.View()
|
||||
view.settings().set(state.VIEW_DATA, {"repo": str(tmp_path), "sha": None, "mode": "branches", "ref": "feature"})
|
||||
st = commands.restore_view(view)
|
||||
assert loads == [("feature", "branches", None, False)] and view.settings().get(state.MODE_SETTING) == "branches"
|
||||
# while the load (stubbed here) is in flight an activation does not start a second one
|
||||
st.token += 1
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1
|
||||
|
||||
|
||||
def test_esc_from_the_files_panel_goes_back_to_the_branches(monkeypatch, loads):
|
||||
monkeypatch.setattr(commands, "show_file", lambda view, st, c: None)
|
||||
view, st = rendered()
|
||||
kept = st.enter()
|
||||
assert kept.mode == "branches"
|
||||
window = sublime.Window()
|
||||
files = [git.FileChange("a.py", "M", False, 1, 1, None)]
|
||||
commands.show_files_panel(window, view, st, files, kept, placeholder="x")
|
||||
_, on_select, _, on_highlight, _ = window.panel
|
||||
on_highlight(0)
|
||||
st.mode = state.MODE_DIFF # the preview drew a diff
|
||||
on_select(-1)
|
||||
assert [m for _, m, _, _ in loads] == ["branches"] and st.in_branches
|
||||
|
||||
|
||||
def test_keymap_context_answers_the_mode():
|
||||
listener = listeners.VdiffEventListener()
|
||||
view, st = rendered()
|
||||
assert view.settings().get(state.MODE_SETTING) == "branches"
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_EQUAL, "branches", False) is True
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_EQUAL, "diff", False) is False
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_NOT_EQUAL, "diff", False) is True
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_NOT_EQUAL, "branches", False) is False
|
||||
# other keys and other views are someone else's business
|
||||
assert listener.on_query_context(view, "setting.vdiff_mode", sublime.OP_EQUAL, "branches", False) is None
|
||||
assert listener.on_query_context(sublime.View(), "vdiff_mode", sublime.OP_EQUAL, "diff", False) is None
|
||||
# a review view without the setting (an older session) is a diff view
|
||||
plain = sublime.View()
|
||||
plain.settings().set(state.VIEW_FLAG, True)
|
||||
assert listener.on_query_context(plain, "vdiff_mode", sublime.OP_EQUAL, "diff", False) is True
|
||||
|
||||
|
||||
def test_branches_view_reloads_when_the_refs_changed(monkeypatch):
|
||||
mtimes = {"/repo/.git/HEAD": 1.0, "/repo/.git/refs/heads": 2.0, "/repo/vdiff/a.py": 5.0}
|
||||
monkeypatch.setattr(branches.git, "ref_paths", lambda repo: ("/repo/.git/HEAD", "/repo/.git/refs/heads"))
|
||||
monkeypatch.setattr(branches.git, "index_path", lambda repo: "/repo/.git/index")
|
||||
monkeypatch.setattr(git, "mtime", lambda path: mtimes.get(path))
|
||||
loads = record_loads(monkeypatch)
|
||||
worktree_loads = []
|
||||
monkeypatch.setattr(branches, "load_worktree", lambda view, st: worktree_loads.append(st.branch_ref))
|
||||
st = make_state()
|
||||
st.branch_changes = [CHANGES[0]]
|
||||
view, st = rendered(st)
|
||||
st.rendered_token = st.token
|
||||
# the refs, then the changed files of the working-tree entry and the index they are staged in
|
||||
assert st.fingerprint == ((1.0, 2.0), (5.0, None))
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert loads == [] and worktree_loads == []
|
||||
mtimes["/repo/.git/HEAD"] = 3.0 # a checkout elsewhere: everything is relisted
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert loads == [("main", "branches", None, True)]
|
||||
st.rendered_token = st.token
|
||||
st.fingerprint = branches.fingerprint(st)
|
||||
# the changed file saved, something staged: only the working tree is relisted
|
||||
mtimes["/repo/vdiff/a.py"] = 6.0
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1 and worktree_loads == ["main"]
|
||||
st.fingerprint = branches.fingerprint(st)
|
||||
mtimes["/repo/.git/index"] = 7.0
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1 and worktree_loads == ["main", "main"]
|
||||
# not while a load is in flight
|
||||
st.token += 1
|
||||
mtimes["/repo/.git/HEAD"] = 4.0
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1 and len(worktree_loads) == 2
|
||||
|
||||
|
||||
def test_load_worktree_relists_only_the_changes_and_keeps_the_caret(monkeypatch):
|
||||
listed = []
|
||||
monkeypatch.setattr(branches.git, "changed_files", lambda repo: listed.append(repo) or [CHANGES[1]])
|
||||
monkeypatch.setattr(branches.git, "index_path", lambda repo: None)
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
branches.load_worktree(view, st)
|
||||
assert listed == ["/repo/vdiff"] and st.branch_changes == [CHANGES[1]]
|
||||
assert rows(view)[0].endswith("│ 1 staged file, 0 unstaged files") and rows(view)[5].endswith("│ default file view mode and some colors now configurable in settings")
|
||||
assert render.caret_index(view) == 5 and st.token == st.rendered_token
|
||||
# a later load wins over a slower relisting
|
||||
pending = []
|
||||
monkeypatch.setattr(branches, "run_async", lambda work, done: pending.append((work, done)))
|
||||
branches.load_worktree(view, st)
|
||||
st.token += 1
|
||||
work, done = pending[0]
|
||||
done([])
|
||||
assert st.branch_changes == [CHANGES[1]]
|
||||
|
||||
|
||||
def test_the_commit_cursor_tints_only_the_right_column_once_its_rule_is_live():
|
||||
# before the restart: Sublime's line highlight, no cursor regions
|
||||
view, st = rendered()
|
||||
assert view.settings().get("highlight_line") is True
|
||||
assert render.KEY_BRANCH_CURSOR not in view.regions
|
||||
# after it: the four cells of the caret's commit, from the gap to the end of the row
|
||||
view, st = rendered(live=True)
|
||||
assert view.settings().get("highlight_line") is False
|
||||
regions, scope, _, _ = view.regions[render.KEY_BRANCH_CURSOR]
|
||||
assert scope == palette.SCOPE_CURSOR
|
||||
width = len(" feature") + branches.LEFT_PAD + 2
|
||||
lines = rows(view)
|
||||
assert [view.text[r.a:r.b] for r in regions] == [line[width:] for line in lines[:4]]
|
||||
# the commits' counts and tags keep the plain red / green
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_INS][0]] == ["v1.1.0", "+260"]
|
||||
assert view.regions[render.KEY_BRANCH_INS][1] == palette.SCOPE_TEXT_INS
|
||||
assert view.regions[render.KEY_BRANCH_CURSOR_INS][0] == [] and view.regions[render.KEY_BRANCH_CURSOR_DEL][0] == []
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
regions = view.regions[render.KEY_BRANCH_CURSOR][0]
|
||||
assert regions[0].a == render.index_point(view, 5) + width
|
||||
# the tint leaves out the counts and tags, which get the cursor's background with their own colour instead:
|
||||
# overlapping regions would let the later one recolour the text
|
||||
text = lambda key: [view.text[r.a:r.b] for r in view.regions[key][0]] # noqa: E731
|
||||
assert text(render.KEY_BRANCH_CURSOR_INS) == ["v1.1.0", "+260"] and text(render.KEY_BRANCH_CURSOR_DEL) == ["-58"]
|
||||
assert view.regions[render.KEY_BRANCH_CURSOR_INS][1] == palette.SCOPE_CURSOR_INS
|
||||
assert text(render.KEY_BRANCH_INS) == [] and text(render.KEY_BRANCH_DEL) == []
|
||||
pieces = sorted(sum((list(view.regions[key][0]) for key in (render.KEY_BRANCH_CURSOR, render.KEY_BRANCH_CURSOR_INS,
|
||||
render.KEY_BRANCH_CURSOR_DEL)), []), key=lambda r: r.a)
|
||||
assert all(a.b <= b.a for a, b in zip(pieces, pieces[1:]))
|
||||
by_row = {}
|
||||
for r in pieces:
|
||||
by_row.setdefault(view.rowcol(r.a)[0] - 1, []).append(view.text[r.a:r.b])
|
||||
assert {row: "".join(parts) for row, parts in by_row.items()} == {i: lines[i][width:] for i in range(5, 9)}
|
||||
# back in a diff the line highlight returns
|
||||
st.change = git.FileChange("x.py", "M", False, 1, 1, None)
|
||||
render.render_message(view, st, "nothing")
|
||||
assert view.settings().get("highlight_line") is True
|
||||
|
||||
|
||||
def test_holding_J_fetches_the_log_once_the_key_rests(monkeypatch):
|
||||
timers = []
|
||||
monkeypatch.setattr(sublime, "set_timeout", lambda fn, delay=0: timers.append((fn, delay)))
|
||||
logged = []
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: logged.append(name) or [])
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["prev_branch"](view, None, st)
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == "github/main" and logged == []
|
||||
assert [delay for _, delay in timers] == [branches.DEBOUNCE_MS] * 3
|
||||
for fn, _ in timers:
|
||||
fn()
|
||||
# only the last selection's fetch ran; the cell moved at once each time
|
||||
assert logged == ["github/main"]
|
||||
selected = view.regions[render.KEY_BRANCH_SEL][0]
|
||||
assert view.text[selected[0].a:selected[0].b].strip() == "main"
|
||||
|
||||
|
||||
def test_entering_the_branches_view_vacates_the_diff_state(monkeypatch):
|
||||
monkeypatch.setattr(branches, "run_async", lambda work, done: None)
|
||||
view = sublime.View()
|
||||
render.init_view(view)
|
||||
st = state.ViewState("/repo/vdiff")
|
||||
st.sha, st.change = "abc", git.FileChange("x.py", "M", False, 1, 1, None)
|
||||
st.files = [st.change]
|
||||
branches.load(view, st)
|
||||
assert st.in_branches and st.sha is None and st.change is None and st.requested is None and st.lines == []
|
||||
assert st.files == [st.change] or st.files == [git.FileChange("x.py", "M", False, 1, 1, None)]
|
||||
@@ -4,6 +4,7 @@ import pytest
|
||||
|
||||
import sublime # the stub, via conftest
|
||||
|
||||
from conftest import put_caret # noqa: E402
|
||||
from vdiff import commands, git, state, utils
|
||||
|
||||
|
||||
@@ -163,6 +164,58 @@ def test_on_cancel_goes_back_to_commit_list(monkeypatch):
|
||||
assert back == [1] and st.sha is None
|
||||
|
||||
|
||||
def test_esc_from_the_reopened_commit_list_returns_to_the_branches_view(monkeypatch):
|
||||
loads = []
|
||||
monkeypatch.setattr(commands.branches, "load", lambda view, st, keep_caret=False: loads.append(st.mode))
|
||||
window = sublime.Window()
|
||||
view = sublime.View()
|
||||
st = state.ViewState("/repo")
|
||||
st.mode = state.MODE_BRANCHES
|
||||
commit = git.Commit("a" * 40, "a" * 7, "me", "today", "subject", 1, 1, 0)
|
||||
# Esc on the list opened straight over the branches view: nothing to put back
|
||||
st.drawn, st.rendered_token = st.describe(), st.token
|
||||
commands.VdiffCommitsCommand(window).show_commits(view, st, [commit], 0)
|
||||
window.panel[1](-1)
|
||||
assert loads == []
|
||||
# reopened after a commit's files were cancelled: the state says branches, the screen still shows the commit
|
||||
st.drawn = (state.MODE_DIFF, "a" * 40, False, "x.py")
|
||||
commands.VdiffCommitsCommand(window).show_commits(view, st, [commit], 0)
|
||||
window.panel[1](-1)
|
||||
assert loads == [state.MODE_BRANCHES]
|
||||
# the same holds for a diff the list was reopened over: the kept working-tree file is shown again
|
||||
shown = []
|
||||
monkeypatch.setattr(commands, "show_file", lambda view, st, c: shown.append(c.path))
|
||||
st.mode, st.change = state.MODE_DIFF, change("kept.py")
|
||||
commands.VdiffCommitsCommand(window).show_commits(view, st, [commit], 0)
|
||||
window.panel[1](-1)
|
||||
assert shown == ["kept.py"]
|
||||
|
||||
|
||||
def test_files_on_a_clean_tree_leave_the_branches_view_in_place(monkeypatch):
|
||||
view, st = sublime.View(), state.ViewState("/repo")
|
||||
messages, notices = [], []
|
||||
monkeypatch.setattr(commands, "open_review", lambda window: (view, st))
|
||||
monkeypatch.setattr(commands, "status", messages.append)
|
||||
monkeypatch.setattr(commands.render, "render_message", lambda view, st, text: notices.append(text))
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: [])
|
||||
window = sublime.Window()
|
||||
st.mode = state.MODE_BRANCHES
|
||||
commands.VdiffFilesCommand(window).run()
|
||||
assert messages == ["no uncommitted changes"] and notices == [] and st.in_branches and window.panel is None
|
||||
# with changes the panel comes up as usual; in a diff view the notice is shown
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: [change("a.py")])
|
||||
commands.VdiffFilesCommand(window).run()
|
||||
assert window.panel is not None
|
||||
# nor does a commit under review give way to it
|
||||
st.mode, st.sha = state.MODE_DIFF, "a" * 40
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: [])
|
||||
commands.VdiffFilesCommand(window).run()
|
||||
assert notices == [] and st.sha == "a" * 40
|
||||
st.sha = None
|
||||
commands.VdiffFilesCommand(window).run()
|
||||
assert notices == ["No uncommitted changes in /repo"]
|
||||
|
||||
|
||||
def test_step_change_uses_blocks(rings):
|
||||
view, st = at_change([(2, 4), (7, 8)], 0)
|
||||
commands.ACTIONS["next_change"](view, None, st)
|
||||
@@ -476,14 +529,6 @@ def test_esc_rewinds_the_file_navigation_counts_from(loading):
|
||||
# --- cycling past the ends --------------------------------------------------
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def rings(monkeypatch):
|
||||
"""Record visual bells instead of drawing them"""
|
||||
bells = []
|
||||
monkeypatch.setattr(commands.render, "flash", lambda view: bells.append(view))
|
||||
return bells
|
||||
|
||||
|
||||
def at_file(files, path):
|
||||
"""A loaded working-tree view sitting on `path`"""
|
||||
view, window = sublime.View(), sublime.Window()
|
||||
@@ -600,6 +645,9 @@ def test_next_unstaged_scans_forward_and_wraps():
|
||||
assert commands._next_unstaged(files, 2) == 2 # the slot we count from counts itself
|
||||
assert commands._next_unstaged(files, 3) == 0 # wraps past the end
|
||||
assert commands._next_unstaged(flagged(True, True), 0) == -1
|
||||
# a partially staged file still has hunks to stage
|
||||
partial = git.FileChange("p.py", "M", True, 1, 1, None, unstaged=True)
|
||||
assert commands._next_unstaged(flagged(True, True) + [partial], 0) == 2
|
||||
|
||||
|
||||
def test_staging_moves_to_the_next_unstaged_file(monkeypatch):
|
||||
@@ -653,6 +701,10 @@ def test_stage_all_and_unstage_all_need_something_to_do(monkeypatch):
|
||||
assert press(monkeypatch, "stage_all", flagged(True, True), "f0.py", []) == []
|
||||
assert press(monkeypatch, "unstage_all", flagged(False, False), "f0.py", []) == []
|
||||
assert messages == ["nothing to stage", "nothing to unstage"]
|
||||
# a partially staged file is something to stage
|
||||
partial = git.FileChange("p.py", "M", True, 1, 1, None, unstaged=True)
|
||||
assert press(monkeypatch, "stage_all", flagged(True) + [partial], "f0.py", flagged(True, True)) == ["f0.py"]
|
||||
assert messages[-1] == "staged 1 file"
|
||||
view, window, st = at_file(flagged(False), "f0.py")
|
||||
st.enter("abc", git.CommitInfo("abc", "abc1234", "Ann", "2026-09-23 10:00", "Fix things", ""))
|
||||
commands.ACTIONS["stage_all"](view, window, st)
|
||||
@@ -670,6 +722,9 @@ def watched(monkeypatch, tmp_path, all_mode):
|
||||
st.files = [change("a.py"), change("b.py")]
|
||||
st.change, st.all_mode = st.files[0], all_mode
|
||||
st.fingerprint = commands.render.fingerprint(st)
|
||||
# git status lists what the view lists, unless a test says otherwise
|
||||
monkeypatch.setattr(commands, "run_async", lambda work, done: done(work()))
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: list(st.files))
|
||||
return st, refreshes
|
||||
|
||||
|
||||
@@ -698,6 +753,27 @@ def test_refresh_if_changed_watches_the_shown_file_and_the_index(monkeypatch, tm
|
||||
assert refreshes == [st]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("all_mode", [False, True])
|
||||
def test_refresh_if_changed_sees_a_file_changed_outside_the_list(monkeypatch, tmp_path, all_mode):
|
||||
st, refreshes = watched(monkeypatch, tmp_path, all_mode=all_mode)
|
||||
# no listed file and not the index moved, but git status now lists c.py too
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: st.files + [change("c.py")])
|
||||
commands.refresh_if_changed(sublime.View(), st)
|
||||
assert refreshes == [st]
|
||||
|
||||
|
||||
def test_a_stale_git_status_does_not_refresh(monkeypatch, tmp_path):
|
||||
st, refreshes = watched(monkeypatch, tmp_path, all_mode=False)
|
||||
pending = []
|
||||
monkeypatch.setattr(commands, "run_async", lambda work, done: pending.append(done))
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: [])
|
||||
commands.refresh_if_changed(sublime.View(), st)
|
||||
# the user moved on to another file before git status answered
|
||||
st.token += 1
|
||||
pending[0]([change("c.py")])
|
||||
assert refreshes == []
|
||||
|
||||
|
||||
def test_staging_the_only_file_leaves_an_empty_listing(monkeypatch):
|
||||
messages = []
|
||||
monkeypatch.setattr(commands.render, "render_message", lambda view, st, text: messages.append(text))
|
||||
@@ -744,9 +820,31 @@ def heading_row(st, path):
|
||||
return next(i for i, (c, _, section) in enumerate(st.all_rows) if section and c.path == path)
|
||||
|
||||
|
||||
def put_caret(view, row):
|
||||
view.sel().clear()
|
||||
view.sel().add(sublime.Region(commands.render.index_point(view, row)))
|
||||
def test_the_header_follows_the_caret_from_file_to_file():
|
||||
from vdiff import listeners
|
||||
view, st = all_files_view()
|
||||
st.files[1] = git.FileChange("b.py", "M", False, 0, 4, None)
|
||||
commands.render.render_all(view, st)
|
||||
st.rendered_token = st.token
|
||||
commands.render.init_view(view)
|
||||
state.put(view, st)
|
||||
title = lambda: view.phantoms[commands.render.PHANTOM_KEY][0].content.split("</div>", 1)[1] # noqa: E731
|
||||
listener = listeners.VdiffEventListener()
|
||||
put_caret(view, heading_row(st, "b.py") + 1)
|
||||
listener.on_selection_modified(view)
|
||||
assert st.change.path == "b.py" and ">b.py<" in title() and '<span class="del">-4</span> <span class="ins">+0</span>' in title()
|
||||
# within the same file nothing is redrawn; back in a.py the header is a.py's again
|
||||
shown = view.phantoms[commands.render.PHANTOM_KEY]
|
||||
listener.on_selection_modified(view)
|
||||
assert view.phantoms[commands.render.PHANTOM_KEY] is shown
|
||||
put_caret(view, heading_row(st, "a.py"))
|
||||
listener.on_selection_modified(view)
|
||||
assert ">a.py<" in title() and '<span class="del">-1</span> <span class="ins">+1</span>' in title()
|
||||
# not while a render is pending: the rows describe the old text
|
||||
st.token += 1
|
||||
put_caret(view, heading_row(st, "b.py"))
|
||||
listener.on_selection_modified(view)
|
||||
assert st.change.path == "a.py"
|
||||
|
||||
|
||||
def test_all_files_step_change_from_a_heading_lands_on_its_first_hunk():
|
||||
@@ -808,3 +906,101 @@ def test_all_files_context_zero_shows_only_changed_lines(monkeypatch):
|
||||
view, st = all_files_view()
|
||||
shown = [line for _, line, _ in st.all_rows if line is not None]
|
||||
assert shown and all(line.kind != " " for line in shown)
|
||||
|
||||
|
||||
def test_refresh_in_the_all_files_view_relists_the_working_tree(monkeypatch):
|
||||
view, st = all_files_view()
|
||||
st.change = st.files[0]
|
||||
monkeypatch.setattr(commands, "run_async", lambda work, done: done(work()))
|
||||
# b.py was reverted and c.py is new since the view was drawn
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: [change("a.py"), change("c.py")])
|
||||
shown = []
|
||||
monkeypatch.setattr(commands, "show_all", lambda view, st, focus=None: shown.append(focus))
|
||||
commands.ACTIONS["refresh"](view, None, st)
|
||||
assert shown == ["a.py"] and [c.path for c in st.files] == ["a.py", "c.py"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("all_mode, expected", [(False, ("file", "b.py")), (True, ("all", "b.py"))])
|
||||
def test_restore_falls_back_to_the_first_changed_file(monkeypatch, tmp_path, all_mode, expected):
|
||||
view = sublime.View()
|
||||
view.settings().set(state.VIEW_DATA, {"repo": str(tmp_path), "sha": None, "path": "gone.py", "all_mode": all_mode})
|
||||
monkeypatch.setattr(commands, "run_async", lambda work, done: done(work()))
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: [change("b.py"), change("c.py")])
|
||||
shown = []
|
||||
monkeypatch.setattr(commands, "show_all", lambda view, st, focus=None: shown.append(("all", st.change.path)))
|
||||
monkeypatch.setattr(commands, "show_file", lambda view, st, c: shown.append(("file", c.path)))
|
||||
commands.restore_view(view)
|
||||
assert shown == [expected]
|
||||
|
||||
|
||||
def test_restore_with_no_changes_left_says_so(monkeypatch, tmp_path):
|
||||
view = sublime.View()
|
||||
view.settings().set(state.VIEW_DATA, {"repo": str(tmp_path), "sha": None, "path": "gone.py"})
|
||||
monkeypatch.setattr(commands, "run_async", lambda work, done: done(work()))
|
||||
monkeypatch.setattr(commands.git, "changed_files", lambda repo: [])
|
||||
messages = []
|
||||
monkeypatch.setattr(commands.render, "render_message", lambda view, st, text: messages.append(text))
|
||||
commands.restore_view(view)
|
||||
assert messages == [f"No uncommitted changes in {tmp_path}"]
|
||||
|
||||
|
||||
def test_open_in_the_all_files_view_maps_a_deleted_row_like_the_single_file_view(tmp_path):
|
||||
from vdiff import parse
|
||||
view, st = all_files_view()
|
||||
st.repo = str(tmp_path)
|
||||
(tmp_path / "a.py").write_text("")
|
||||
(tmp_path / "b.py").write_text("")
|
||||
lines_b = [parse.Line(" ", i, i, f"b{i}") for i in range(1, 5)] + [parse.Line("-", 5, None, "old b5"),
|
||||
parse.Line(" ", 6, 5, "b6")]
|
||||
st.all_diffs["b.py"] = (lines_b, parse.change_blocks(lines_b), False)
|
||||
commands.render.render_all(view, st)
|
||||
opened = []
|
||||
|
||||
class Window:
|
||||
def open_file(self, name, flags=0):
|
||||
opened.append(name)
|
||||
|
||||
def open_at(match):
|
||||
put_caret(view, next(i for i, (_, line, _) in enumerate(st.all_rows) if line is not None and match(line)))
|
||||
commands.ACTIONS["open"](view, Window(), st)
|
||||
|
||||
# the deleted row opens at the line that took its place, as in the single-file view, not at line 1
|
||||
open_at(lambda line: line.kind == "-")
|
||||
# a surviving row keeps its own number
|
||||
open_at(lambda line: line.new_no == 26)
|
||||
assert opened == [f"{tmp_path}/b.py:5", f"{tmp_path}/a.py:26"]
|
||||
|
||||
|
||||
def test_a_blank_row_in_the_all_files_view_is_no_file(monkeypatch):
|
||||
view, st = all_files_view()
|
||||
messages, ran = [], []
|
||||
monkeypatch.setattr(commands, "status", messages.append)
|
||||
monkeypatch.setattr(commands, "run_async", lambda work, done: ran.append(work))
|
||||
# the caret was on a.py, then moved to the blank row above b.py: git actions and open act on nothing
|
||||
put_caret(view, heading_row(st, "a.py") + 1)
|
||||
commands.render.follow_caret(view, st)
|
||||
put_caret(view, heading_row(st, "b.py") - 1)
|
||||
commands.ACTIONS["discard"](view, None, st)
|
||||
commands.ACTIONS["stage"](view, None, st)
|
||||
commands.ACTIONS["open"](view, None, st)
|
||||
assert ran == [] and messages == ["no file under the caret"] * 3
|
||||
|
||||
|
||||
@pytest.mark.parametrize("action, path", [("next_file", "b.py"), ("prev_file", "a.py")])
|
||||
def test_a_blank_row_steps_files_as_the_gap_above_the_file_below(action, path):
|
||||
view, st = all_files_view()
|
||||
st.change = st.files[0]
|
||||
put_caret(view, heading_row(st, "b.py") - 1)
|
||||
commands.ACTIONS[action](view, None, st)
|
||||
assert st.change.path == path
|
||||
|
||||
|
||||
def test_a_blank_row_steps_changes_as_the_gap_above_the_file_below():
|
||||
view, st = all_files_view()
|
||||
put_caret(view, heading_row(st, "b.py") - 1)
|
||||
commands.ACTIONS["next_change"](view, None, st)
|
||||
assert st.change.path == "b.py"
|
||||
put_caret(view, heading_row(st, "b.py") - 1)
|
||||
commands.ACTIONS["prev_change"](view, None, st)
|
||||
# a.py's last hunk, not the first or last of the whole list from nowhere
|
||||
assert st.change.path == "a.py" and commands.render.caret_index(view) == st.all_change_rows[1]
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
|
||||
import pytest
|
||||
@@ -43,12 +44,25 @@ def test_changed_files_all_kinds(repo):
|
||||
sh(repo, "add", "b.txt") # staged M
|
||||
os.remove(os.path.join(repo, "gone.py")) # unstaged D
|
||||
write(repo, "sub/new.py", "x = 1\ny = 2") # untracked, no trailing newline
|
||||
write(repo, "c.txt", "c\n")
|
||||
sh(repo, "add", "c.txt")
|
||||
write(repo, "c.txt", "c\nd\n") # partially staged: staged A, unstaged M
|
||||
changes = {c.path: c for c in git.changed_files(repo)}
|
||||
assert set(changes) == {"a.py", "b.txt", "gone.py", "sub/new.py"}
|
||||
assert changes["a.py"] == git.FileChange("a.py", "M", False, 1, 1, None)
|
||||
assert set(changes) == {"a.py", "b.txt", "c.txt", "gone.py", "sub/new.py"}
|
||||
assert changes["a.py"] == git.FileChange("a.py", "M", False, 1, 1, None, unstaged=True)
|
||||
assert changes["b.txt"] == git.FileChange("b.txt", "M", True, 1, 0, None)
|
||||
assert changes["c.txt"] == git.FileChange("c.txt", "M", True, 2, 0, None, unstaged=True)
|
||||
assert changes["gone.py"].status == "D" and changes["gone.py"].deletions == 1
|
||||
assert changes["sub/new.py"] == git.FileChange("sub/new.py", "?", False, 2, 0, None)
|
||||
assert changes["sub/new.py"] == git.FileChange("sub/new.py", "?", False, 2, 0, None, unstaged=True)
|
||||
|
||||
|
||||
def test_worktree_stats_counts_a_partially_staged_file_in_both_and_a_binary_in_neither_total():
|
||||
changes = [git.FileChange("a.py", "M", False, 1, 1, None, unstaged=True),
|
||||
git.FileChange("b.txt", "M", True, 1, 0, None),
|
||||
git.FileChange("c.txt", "M", True, 2, 0, None, unstaged=True),
|
||||
git.FileChange("img.png", "M", True, None, None, None)]
|
||||
assert git.worktree_stats(changes) == git.WorkTree(staged=3, unstaged=2, files=4, insertions=4, deletions=1)
|
||||
assert git.worktree_stats([]) == git.WorkTree(0, 0, 0, 0, 0)
|
||||
|
||||
|
||||
def test_full_diff_working_tree(repo):
|
||||
@@ -296,3 +310,250 @@ def test_head_message_without_a_commit_raises(tmp_path):
|
||||
sh(fresh, "init", "-q", "-b", "main")
|
||||
with pytest.raises(git.GitError):
|
||||
git.head_message(fresh)
|
||||
|
||||
|
||||
# --- branches ---------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def remote(repo, tmp_path_factory):
|
||||
"""A bare `origin` holding main, with the repo's main tracking it"""
|
||||
bare = str(tmp_path_factory.mktemp("origin"))
|
||||
sh(bare, "init", "-q", "--bare", "-b", "main")
|
||||
sh(repo, "remote", "add", "origin", bare)
|
||||
sh(repo, "push", "-q", "-u", "origin", "main")
|
||||
return bare
|
||||
|
||||
|
||||
def clone(bare, tmp_path_factory):
|
||||
"""A second working copy of `bare`, to push foreign commits from"""
|
||||
other = str(tmp_path_factory.mktemp("other"))
|
||||
sh(other, "clone", "-q", bare, ".")
|
||||
sh(other, "config", "user.email", "o@example.com")
|
||||
sh(other, "config", "user.name", "Other")
|
||||
return other
|
||||
|
||||
|
||||
def commit_file(repo, name, text, message):
|
||||
write(repo, name, text)
|
||||
sh(repo, "add", "-A")
|
||||
sh(repo, "commit", "-q", "-m", message)
|
||||
|
||||
|
||||
def by_name(repo):
|
||||
return {r.name: r for r in git.branches(repo)}
|
||||
|
||||
|
||||
def test_branches_lists_locals_remotes_and_tracking(repo, remote, tmp_path_factory):
|
||||
sh(repo, "branch", "feature/x")
|
||||
sh(repo, "push", "-q", "-u", "origin", "feature/x")
|
||||
sh(repo, "branch", "local-only")
|
||||
commit_file(repo, "ahead.txt", "a\n", "ahead")
|
||||
other = clone(remote, tmp_path_factory)
|
||||
commit_file(other, "behind.txt", "b\n", "behind")
|
||||
sh(other, "push", "-q", "origin", "main")
|
||||
sh(other, "push", "-q", "origin", "--delete", "feature/x")
|
||||
sh(repo, "fetch", "-q", "--prune")
|
||||
# the remote's symbolic HEAD is a row of for-each-ref too
|
||||
sh(repo, "remote", "set-head", "origin", "main")
|
||||
|
||||
refs = by_name(repo)
|
||||
assert set(refs) == {"main", "feature/x", "local-only", "origin/main"}
|
||||
main = refs["main"]
|
||||
assert main.current and main.remote is None and main.upstream == "origin/main"
|
||||
assert (main.ahead, main.behind, main.gone) == (1, 1, False)
|
||||
assert refs["feature/x"].gone and refs["feature/x"].upstream == "origin/feature/x"
|
||||
assert refs["local-only"].upstream is None and not refs["local-only"].current
|
||||
assert (main.upstream_remote, main.upstream_branch) == ("origin", "main")
|
||||
assert refs["local-only"].upstream_remote is None and refs["local-only"].upstream_branch is None
|
||||
origin_main = refs["origin/main"]
|
||||
assert (origin_main.remote, origin_main.branch, origin_main.current) == ("origin", "main", False)
|
||||
assert len(origin_main.sha) >= 7
|
||||
# locals come before remotes, in git's own order
|
||||
assert [r.name for r in git.branches(repo)] == ["feature/x", "local-only", "main", "origin/main"]
|
||||
|
||||
|
||||
def test_remotes_lists_a_remote_without_refs(repo, remote):
|
||||
sh(repo, "remote", "add", "github", "/nowhere")
|
||||
assert git.remotes(repo) == ["github", "origin"]
|
||||
|
||||
|
||||
def test_head_sha_on_a_branch_detached_and_without_commits(repo, tmp_path):
|
||||
sha = git.head_sha(repo)
|
||||
assert len(sha) >= 7 and by_name(repo)["main"].current
|
||||
sh(repo, "checkout", "-q", "--detach")
|
||||
assert git.head_sha(repo) == sha and not any(r.current for r in git.branches(repo))
|
||||
empty = str(tmp_path / "empty")
|
||||
os.makedirs(empty)
|
||||
sh(empty, "init", "-q", "-b", "main")
|
||||
assert git.head_sha(empty) == "" and git.branches(empty) == []
|
||||
|
||||
|
||||
def test_ref_log_carries_tags_dates_and_stats(repo, remote):
|
||||
commit_file(repo, "new.py", "one\ntwo\n", "added a file")
|
||||
sh(repo, "tag", "v1.0.0")
|
||||
sh(repo, "tag", "-a", "release", "-m", "annotated")
|
||||
sh(repo, "commit", "-q", "--allow-empty", "-m", "empty")
|
||||
|
||||
empty, added, initial = git.ref_log(repo, "main", 10)
|
||||
assert (empty.subject, empty.tags, empty.files) == ("empty", (), None)
|
||||
assert added.tags == ("release", "v1.0.0") or added.tags == ("v1.0.0", "release")
|
||||
assert (added.files, added.insertions, added.deletions) == (1, 2, 0)
|
||||
assert re.fullmatch(r"\d\d\.\d\d\.\d{4}", added.date) and added.author == "Test"
|
||||
assert initial.tags == () and initial.files == 3
|
||||
# a remote ref logs too, and the count caps the list
|
||||
assert [c.subject for c in git.ref_log(repo, "origin/main", 1)] == ["initial"]
|
||||
# the recent-commits panel keeps its relative dates and carries the same tags
|
||||
recent = git.recent_commits(repo, 2)
|
||||
assert recent[0].tags == () and recent[1].tags == added.tags and recent[0].date.endswith("ago")
|
||||
|
||||
|
||||
def test_checkout_tracks_a_remote_branch_once_and_reuses_the_local(repo, remote, tmp_path_factory):
|
||||
other = clone(remote, tmp_path_factory)
|
||||
sh(other, "checkout", "-q", "-b", "topic")
|
||||
commit_file(other, "t.txt", "t\n", "topic work")
|
||||
sh(other, "push", "-q", "-u", "origin", "topic")
|
||||
sh(repo, "fetch", "-q")
|
||||
|
||||
refs = by_name(repo)
|
||||
assert "topic" not in refs
|
||||
git.checkout(repo, refs["origin/topic"], local_names=[])
|
||||
refs = by_name(repo)
|
||||
assert refs["topic"].current and refs["topic"].upstream == "origin/topic"
|
||||
assert os.path.exists(os.path.join(repo, "t.txt"))
|
||||
# back on main, the remote row now checks out the existing local branch rather than failing
|
||||
git.checkout(repo, refs["main"])
|
||||
assert by_name(repo)["main"].current
|
||||
git.checkout(repo, refs["origin/topic"], local_names=["topic"])
|
||||
assert by_name(repo)["topic"].current
|
||||
|
||||
|
||||
def test_checkout_detached(repo, remote):
|
||||
git.checkout_detached(repo, "origin/main")
|
||||
refs = by_name(repo)
|
||||
assert not any(r.current for r in refs.values()) and git.head_sha(repo) == refs["origin/main"].sha
|
||||
|
||||
|
||||
def test_delete_branch_refuses_unmerged_then_forces(repo):
|
||||
sh(repo, "checkout", "-q", "-b", "side")
|
||||
commit_file(repo, "s.txt", "s\n", "side work")
|
||||
sh(repo, "checkout", "-q", "main")
|
||||
with pytest.raises(git.GitError) as caught:
|
||||
git.delete_branch(repo, "side")
|
||||
assert "not fully merged" in caught.value.stderr
|
||||
assert "side" in by_name(repo)
|
||||
git.delete_branch(repo, "side", force=True)
|
||||
assert "side" not in by_name(repo)
|
||||
# a merged branch goes without force
|
||||
sh(repo, "branch", "merged")
|
||||
git.delete_branch(repo, "merged")
|
||||
assert "merged" not in by_name(repo)
|
||||
|
||||
|
||||
def test_fetch_into_fast_forwards_and_refuses_non_ff(repo, remote, tmp_path_factory):
|
||||
sh(repo, "checkout", "-q", "-b", "work")
|
||||
other = clone(remote, tmp_path_factory)
|
||||
commit_file(other, "n.txt", "n\n", "upstream work")
|
||||
sh(other, "push", "-q", "origin", "main")
|
||||
|
||||
git.fetch_into(repo, "origin", "main", "main")
|
||||
refs = by_name(repo)
|
||||
assert refs["main"].sha == refs["origin/main"].sha and refs["main"].ahead == 0
|
||||
# diverge main, then the fast-forward is refused
|
||||
sh(repo, "checkout", "-q", "main")
|
||||
commit_file(repo, "m.txt", "m\n", "local work")
|
||||
sh(repo, "checkout", "-q", "work")
|
||||
commit_file(other, "o.txt", "o\n", "more upstream work")
|
||||
sh(other, "push", "-q", "origin", "main")
|
||||
with pytest.raises(git.GitError):
|
||||
git.fetch_into(repo, "origin", "main", "main")
|
||||
# nor does git update the checked-out branch this way
|
||||
with pytest.raises(git.GitError):
|
||||
git.fetch_into(repo, "origin", "main", "work")
|
||||
|
||||
|
||||
def test_pull_fast_forwards_the_current_branch(repo, remote, tmp_path_factory):
|
||||
other = clone(remote, tmp_path_factory)
|
||||
commit_file(other, "n.txt", "n\n", "upstream work")
|
||||
sh(other, "push", "-q", "origin", "main")
|
||||
git.pull(repo)
|
||||
assert os.path.exists(os.path.join(repo, "n.txt"))
|
||||
assert by_name(repo)["main"].behind == 0
|
||||
|
||||
|
||||
def test_push_sets_the_upstream_once(repo, remote):
|
||||
sh(repo, "checkout", "-q", "-b", "topic")
|
||||
commit_file(repo, "t.txt", "t\n", "topic work")
|
||||
assert by_name(repo)["topic"].upstream is None
|
||||
git.push(repo, "origin", "topic", set_upstream=True)
|
||||
topic = by_name(repo)["topic"]
|
||||
assert topic.upstream == "origin/topic" and (topic.ahead, topic.behind) == (0, 0)
|
||||
commit_file(repo, "t.txt", "tt\n", "more topic work")
|
||||
assert by_name(repo)["topic"].ahead == 1
|
||||
git.push(repo, "origin", "topic")
|
||||
assert by_name(repo)["topic"].ahead == 0
|
||||
|
||||
|
||||
def test_push_goes_to_a_differently_named_upstream(repo, remote):
|
||||
sh(repo, "checkout", "-q", "-b", "foo")
|
||||
commit_file(repo, "f.txt", "f\n", "foo work")
|
||||
sh(repo, "push", "-q", "-u", "origin", "foo:bar")
|
||||
foo = by_name(repo)["foo"]
|
||||
assert (foo.upstream, foo.upstream_remote, foo.upstream_branch) == ("origin/bar", "origin", "bar")
|
||||
commit_file(repo, "f.txt", "ff\n", "more foo work")
|
||||
git.push(repo, "origin", "foo", remote_branch="bar")
|
||||
refs = by_name(repo)
|
||||
assert refs["foo"].ahead == 0 and "origin/foo" not in refs
|
||||
# an upstream that is a local branch has no remote
|
||||
sh(repo, "branch", "--set-upstream-to=main", "foo")
|
||||
foo = by_name(repo)["foo"]
|
||||
assert (foo.upstream, foo.upstream_remote, foo.upstream_branch) == ("main", None, None)
|
||||
|
||||
|
||||
def test_fetch_all_prunes_a_deleted_remote_branch(repo, remote, tmp_path_factory):
|
||||
other = clone(remote, tmp_path_factory)
|
||||
sh(other, "checkout", "-q", "-b", "gone")
|
||||
commit_file(other, "g.txt", "g\n", "to be deleted")
|
||||
sh(other, "push", "-q", "origin", "gone")
|
||||
git.fetch_all(repo)
|
||||
assert "origin/gone" in by_name(repo)
|
||||
sh(other, "push", "-q", "origin", "--delete", "gone")
|
||||
git.fetch_all(repo)
|
||||
assert "origin/gone" not in by_name(repo)
|
||||
|
||||
|
||||
def test_run_passes_env_and_closes_stdin(repo):
|
||||
assert git.run(repo, ["var", "GIT_EDITOR"], env={"GIT_EDITOR": "xyz-editor"}).strip() == "xyz-editor"
|
||||
# the inherited environment stays: git still finds its config and the user's PATH
|
||||
assert git.run(repo, ["config", "user.name"]).strip() == "Test"
|
||||
|
||||
|
||||
def test_ref_paths_point_into_the_git_dir(repo, tmp_path_factory):
|
||||
paths = git.ref_paths(repo)
|
||||
assert [os.path.relpath(p, repo) for p in paths] == [".git/" + name for name in git.REF_PATH_NAMES]
|
||||
assert os.path.exists(paths[0]) and os.path.isdir(paths[4])
|
||||
assert git.ref_paths(str(tmp_path_factory.mktemp("not-a-repo"))) == ()
|
||||
# the directories a slashed branch and a remote put their refs in: those are the ones their updates touch
|
||||
sh(repo, "branch", "feature/x")
|
||||
sh(repo, "update-ref", "refs/remotes/origin/main", "HEAD")
|
||||
nested = [os.path.relpath(p, repo) for p in git.ref_paths(repo)[len(git.REF_PATH_NAMES):]]
|
||||
assert nested == [".git/refs/heads/feature", ".git/refs/remotes/origin"]
|
||||
|
||||
|
||||
def test_ref_paths_walk_again_only_when_a_ref_directory_moved(repo, monkeypatch):
|
||||
sh(repo, "branch", "feature/x")
|
||||
git.ref_paths(repo)
|
||||
walks = []
|
||||
real_walk = os.walk
|
||||
monkeypatch.setattr(git.os, "walk", lambda root, *args: walks.append(root) or real_walk(root, *args))
|
||||
git.ref_paths(repo)
|
||||
assert walks == [] # nothing moved: the directories found last time stand
|
||||
# a branch two levels down adds a directory inside a nested one, whose mtime moves
|
||||
sh(repo, "branch", "feature/deep/y")
|
||||
nested = [os.path.relpath(p, repo) for p in git.ref_paths(repo)[len(git.REF_PATH_NAMES):]]
|
||||
assert walks and nested == [".git/refs/heads/feature", ".git/refs/heads/feature/deep"]
|
||||
|
||||
|
||||
def test_run_keeps_gits_messages_in_english(repo):
|
||||
# a localized git would translate the refusal delete_branch tells apart by its text
|
||||
assert "LC_ALL=C" in git.run(repo, ["-c", "alias.showenv=!env", "showenv"]).split("\n")
|
||||
|
||||
@@ -157,3 +157,72 @@ def test_the_status_letter_is_white_on_the_heading_unless_set(tmp_path, monkeypa
|
||||
colour_option(monkeypatch, "file_header_status_foreground", "#ffff00")
|
||||
palette.ensure(sublime.View())
|
||||
assert by_scope(tmp_path)[palette.SCOPE_FILE_STATUS]["foreground"] == "#ffff00"
|
||||
|
||||
|
||||
def test_red_and_green_text_rules_share_the_heading_colours_on_the_editor_background(tmp_path, monkeypatch):
|
||||
view = sublime.View()
|
||||
palette.ensure(view)
|
||||
rules = by_scope(tmp_path)
|
||||
plain = palette._nudge(palette._global_background(view))
|
||||
assert rules[palette.SCOPE_TEXT_DEL] == {"scope": palette.SCOPE_TEXT_DEL, "background": plain,
|
||||
"foreground": palette.FILE_DEL_FOREGROUND, "font_style": "bold"}
|
||||
assert rules[palette.SCOPE_TEXT_INS]["foreground"] == palette.FILE_INS_FOREGROUND
|
||||
colour_option(monkeypatch, "file_header_inserted_foreground", "#00ff00")
|
||||
palette.ensure(sublime.View())
|
||||
assert by_scope(tmp_path)[palette.SCOPE_TEXT_INS]["foreground"] == "#00ff00"
|
||||
# until the override is live the scheme's diff tints stand in
|
||||
assert palette.text_scope(view, "del") == palette.SCOPE_DEL
|
||||
assert palette.text_scope(view, "ins") == palette.SCOPE_INS
|
||||
assert palette.count_scope(view, "del") == palette.SCOPE_DEL
|
||||
view.override_loaded = True
|
||||
assert palette.text_scope(view, "del") == palette.SCOPE_TEXT_DEL
|
||||
assert palette.text_scope(view, "ins") == palette.SCOPE_TEXT_INS
|
||||
assert palette.count_scope(view, "del") == palette.SCOPE_FILE_DEL_COUNT
|
||||
assert palette.count_scope(view, "ins") == palette.SCOPE_FILE_INS_COUNT
|
||||
|
||||
|
||||
def test_the_cursor_count_rules_share_the_cursor_background_and_the_heading_colours(tmp_path, monkeypatch):
|
||||
colour_option(monkeypatch, "file_header_inserted_foreground", "#00ff00")
|
||||
view = sublime.View()
|
||||
palette.ensure(view)
|
||||
rules = by_scope(tmp_path)
|
||||
assert rules[palette.SCOPE_CURSOR_INS] == {"scope": palette.SCOPE_CURSOR_INS, "background": rules[palette.SCOPE_CURSOR]["background"],
|
||||
"foreground": "#00ff00", "font_style": "bold"}
|
||||
assert rules[palette.SCOPE_CURSOR_DEL]["foreground"] == palette.FILE_DEL_FOREGROUND
|
||||
# the text scope stands in until the rule is live
|
||||
assert palette.cursor_text_scope(view, "ins") == palette.SCOPE_INS
|
||||
view.override_loaded = True
|
||||
assert palette.cursor_text_scope(view, "ins") == palette.SCOPE_CURSOR_INS
|
||||
|
||||
|
||||
def test_the_restart_notice_is_claimed_per_view_kind(tmp_path):
|
||||
view = sublime.View()
|
||||
palette.ensure(view)
|
||||
# nothing live yet: each kind of view asks once
|
||||
assert palette.claim_restart_notice(view, palette.DIFF_SCOPES)
|
||||
assert not palette.claim_restart_notice(view, palette.DIFF_SCOPES)
|
||||
assert palette.claim_restart_notice(view, palette.BRANCH_SCOPES, tokens=False)
|
||||
assert not palette.claim_restart_notice(view, palette.BRANCH_SCOPES, tokens=False)
|
||||
# an upgrade that adds only the branches rules: a diff view, whose rules are live, says nothing
|
||||
palette.reset()
|
||||
palette.ensure(view)
|
||||
view.override_loaded = True
|
||||
for scope in palette.BRANCH_SCOPES[3:]:
|
||||
view.styles[scope] = {"foreground": sublime.DEFAULT_FG} # known to the scheme, but without a background: not live
|
||||
assert not palette.claim_restart_notice(view, palette.DIFF_SCOPES)
|
||||
assert palette.claim_restart_notice(view, palette.BRANCH_SCOPES, tokens=False)
|
||||
|
||||
|
||||
def test_the_commit_cursor_rule_uses_the_line_highlight_colour(tmp_path, monkeypatch):
|
||||
view = sublime.View()
|
||||
palette.ensure(view)
|
||||
rule = by_scope(tmp_path)[palette.SCOPE_CURSOR]
|
||||
assert rule["background"] == "#3b4350" and rule["foreground"] == sublime.DEFAULT_FG
|
||||
assert palette.cursor_scope(view) is None
|
||||
view.override_loaded = True
|
||||
assert palette.cursor_scope(view) == palette.SCOPE_CURSOR
|
||||
# a scheme without a line highlight: the background nudged towards the foreground
|
||||
assert palette._blend("#000000", "#ffffff", 0.12) == "#1f1f1f"
|
||||
assert palette._blend("#303841", "#d8dee9", 0.12) == "#444c55"
|
||||
monkeypatch.setattr(sublime.View, "style", lambda self: {})
|
||||
assert palette._line_highlight(view) == palette._blend("#000000", sublime.DEFAULT_FG, palette.CURSOR_BLEND)
|
||||
|
||||
@@ -159,7 +159,7 @@ def test_help_popup_lists_every_key():
|
||||
assert "next / previous change" in html and "open the real file at this line" in html
|
||||
# working-tree mode: nothing dimmed, every single-action row is a link
|
||||
assert 'class="dim"' not in html and "uncommitted only" not in html
|
||||
assert 'href="discard"' in html and 'href="files"' in html and 'href="close"' in html
|
||||
assert 'href="discard"' in html and 'href="files"' in html and 'href="branches"' in html and 'href="close"' in html
|
||||
# rows covering two actions stay plain text
|
||||
assert 'href="next_change"' not in html and 'href="stage"' not in html
|
||||
# the popup does not list the key that opens it
|
||||
@@ -196,7 +196,7 @@ def test_help_popup_toggles_and_navigates():
|
||||
|
||||
|
||||
# keymap spellings that the popup shows as a symbol
|
||||
DISPLAY_KEYS = {"enter": "⏎", "escape": "esc"}
|
||||
DISPLAY_KEYS = {"enter": "⏎", "escape": "esc", "shift+enter": "shift+⏎"}
|
||||
|
||||
|
||||
def keymap_bindings():
|
||||
@@ -205,19 +205,37 @@ def keymap_bindings():
|
||||
return json.load(f)
|
||||
|
||||
|
||||
def binding_mode(binding):
|
||||
"""The vdiff_mode a binding is limited to, None when it applies in every mode"""
|
||||
modes = [c["operand"] for c in binding["context"] if c["key"] == "vdiff_mode"]
|
||||
assert len(modes) <= 1, binding["keys"]
|
||||
# a setting context does not compare strings; the plugin answers vdiff_mode itself
|
||||
assert not any(c["key"] == "setting.vdiff_mode" for c in binding["context"]), binding["keys"]
|
||||
return modes[0] if modes else None
|
||||
|
||||
|
||||
def test_keymap_matches_help_table():
|
||||
"""The keymap, ACTIONS and the popup agree on both the actions and the keys that reach them"""
|
||||
"""Per mode, the keymap, ACTIONS and the popup agree on both the actions and the keys that reach them"""
|
||||
bindings = keymap_bindings()
|
||||
|
||||
assert all(b["command"] == "vdiff_action" for b in bindings)
|
||||
bound = {b["args"]["action"] for b in bindings}
|
||||
listed = {action for k in render.KEYS for action in k.actions}
|
||||
# "?" opens the popup, so the popup leaves it out
|
||||
assert bound == set(commands.ACTIONS) == listed | {"help"}
|
||||
|
||||
# rebinding a key without updating the table would leave the popup and status bar lying
|
||||
bound_keys = {DISPLAY_KEYS.get(key, key) for b in bindings for key in b["keys"]}
|
||||
assert bound_keys == {token for k in render.KEYS for token in k.keys.split() if token != "/"} | {"?"}
|
||||
assert all({c["key"] for c in b["context"]} >= {"setting.vdiff_view"} for b in bindings)
|
||||
assert {binding_mode(b) for b in bindings} == {None, "diff", "branches"}
|
||||
bound_all = set()
|
||||
for mode, table in render.MODE_KEY_GROUPS.items():
|
||||
applicable = [b for b in bindings if binding_mode(b) in (None, mode)]
|
||||
# one meaning per key within a mode
|
||||
keys = [key for b in applicable for key in b["keys"]]
|
||||
assert len(keys) == len(set(keys)), mode
|
||||
bound = {b["args"]["action"] for b in applicable}
|
||||
listed = {action for k in render.keys(mode) for action in k.actions}
|
||||
# "?" opens the popup, so the popup leaves it out
|
||||
assert bound == listed | {"help"}, mode
|
||||
# rebinding a key without updating the table would leave the popup and status bar lying
|
||||
bound_keys = {DISPLAY_KEYS.get(key, key) for key in keys}
|
||||
assert bound_keys == {token for k in render.keys(mode) for token in k.keys.split() if token != "/"} | {"?"}, mode
|
||||
bound_all |= bound
|
||||
assert bound_all == set(commands.ACTIONS)
|
||||
|
||||
|
||||
def test_no_binding_yields_to_vintage_command_mode():
|
||||
@@ -258,13 +276,14 @@ def test_summary_counts_staged_and_unstaged_files():
|
||||
git.FileChange("a.py", "M", True, 1, 1, None),
|
||||
git.FileChange("b.py", "M", False, 1, 1, None),
|
||||
git.FileChange("c.py", "?", False, 1, 0, None),
|
||||
git.FileChange("d.py", "M", True, 2, 0, None, unstaged=True), # partially staged: on both sides, as in the branches view
|
||||
]
|
||||
render.render(view, st)
|
||||
summary = header(view).split('<div class="summary">')[1].split("</div>")[0]
|
||||
|
||||
# the untracked file's whole content counts as insertions, the way git.changed_files records it
|
||||
assert summary.startswith("1 staged, 2 unstaged · ")
|
||||
assert '<span class="del">-2</span>' in summary and '<span class="ins">+3</span>' in summary
|
||||
assert summary.startswith("2 staged, 3 unstaged · ")
|
||||
assert '<span class="del">-2</span>' in summary and '<span class="ins">+5</span>' in summary
|
||||
|
||||
|
||||
def test_summary_totals_skip_binary_files_but_still_count_them():
|
||||
@@ -305,6 +324,23 @@ def test_summary_totals_a_commit_and_owns_the_date():
|
||||
assert 'class="commit"' not in html
|
||||
|
||||
|
||||
def test_the_all_files_title_shows_the_current_files_counts_not_the_totals():
|
||||
st = state.ViewState("/repo", all_mode=True)
|
||||
st.files = [git.FileChange("x.py", "M", False, 3, 2, None), git.FileChange("y.py", "M", True, 7, 0, None),
|
||||
git.FileChange("logo.png", "M", False, None, None, None)]
|
||||
st.change = st.files[1]
|
||||
# every file's totals belong on the summary line only
|
||||
html = render._all_header_html(st)
|
||||
title = html.split("</div>", 1)[1]
|
||||
assert '<span class="del">-0</span> <span class="ins">+7</span>' in title and "+10" not in title
|
||||
assert '<span class="del">-2</span> <span class="ins">+10</span>' in html.split("</div>", 1)[0]
|
||||
st.change = st.files[2]
|
||||
assert '<span class="state">binary</span>' in render._all_header_html(st).split("</div>", 1)[1]
|
||||
# file by file, the counts handed in are the shown file's own
|
||||
st.all_mode, st.change = False, st.files[0]
|
||||
assert '<span class="del">-4</span> <span class="ins">+5</span>' in render.header_html(st, 5, 4)
|
||||
|
||||
|
||||
def test_summary_is_omitted_without_a_file_list():
|
||||
view = sublime.View()
|
||||
render.init_view(view)
|
||||
@@ -432,3 +468,50 @@ def test_restart_notice_when_the_override_cannot_take_effect_yet(monkeypatch):
|
||||
# said once per scheme, not once per render
|
||||
render.render(view, make_state())
|
||||
assert said == ["vDiff: " + render.NEEDS_RESTART]
|
||||
|
||||
|
||||
# --- the branches view's keys ----------------------------------------------
|
||||
|
||||
|
||||
def test_help_popup_follows_the_mode():
|
||||
st = make_state()
|
||||
st.mode = state.MODE_BRANCHES
|
||||
_, html = help_popup(st)
|
||||
for keys in ("J K", "j k", "o v", "⏎", "shift+⏎", "L", "P", "F", "d", "f", "c", "b", "r", "esc"):
|
||||
assert f">{keys}<" in html, keys
|
||||
assert "next / previous branch" in html and "fetch all remotes" in html
|
||||
assert ">s / S<" not in html and ">n p<" not in html and ">v<" not in html
|
||||
# a commit shown before switching dims nothing here: the branch keys do not depend on it
|
||||
st.sha = "abc"
|
||||
_, html = help_popup(st)
|
||||
assert 'class="dim"' not in html and 'href="checkout"' in html and 'href="pull"' in html
|
||||
# the diff popup lists the way in
|
||||
st.mode = state.MODE_DIFF
|
||||
_, html = help_popup(st)
|
||||
assert ">b<" in html and 'href="branches"' in html and ">J K<" not in html
|
||||
|
||||
|
||||
def test_status_hints_follow_the_mode():
|
||||
view = sublime.View()
|
||||
render.init_view(view)
|
||||
assert view.status[render.STATUS_KEY] == render.key_hints() and "b branches" in render.key_hints()
|
||||
hints = render.key_hints(state.MODE_BRANCHES)
|
||||
assert "J K branch" in hints and "L pull" in hints and "s / S" not in hints
|
||||
render.init_view(view, state.MODE_BRANCHES)
|
||||
assert view.status[render.STATUS_KEY] == hints and view.settings().get(state.MODE_SETTING) == "branches"
|
||||
|
||||
|
||||
def test_all_files_view_tokenises_only_once_the_colours_can_show(monkeypatch):
|
||||
calls = []
|
||||
monkeypatch.setattr(render, "_all_colours", lambda view, st, paths: calls.append(list(paths)))
|
||||
st = make_state()
|
||||
st.all_mode = True
|
||||
st.files = [st.change]
|
||||
st.all_diffs = {st.change.path: (st.lines, st.blocks, False)}
|
||||
view = sublime.View()
|
||||
render.init_view(view)
|
||||
# before the restart that loads the scheme rules the colours could not be painted: no tokenising
|
||||
render.render_all(view, st)
|
||||
assert calls == []
|
||||
render.render_all(with_loaded_override(view), st)
|
||||
assert calls == [[st.change.path]]
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
[
|
||||
{ "caption": "vDiff: Changed Files", "command": "vdiff_files" },
|
||||
{ "caption": "vDiff: Recent Commits", "command": "vdiff_commits" }
|
||||
{ "caption": "vDiff: Recent Commits", "command": "vdiff_commits" },
|
||||
{ "caption": "vDiff: Branches", "command": "vdiff_branches" }
|
||||
]
|
||||
|
||||
713
vdiff/branches.py
Normal file
713
vdiff/branches.py
Normal file
@@ -0,0 +1,713 @@
|
||||
"""The branches view: local branches and remotes in a left column, the selected branch's log on the right
|
||||
|
||||
Drawn into the same review view as the diffs, as plain text rows of two padded columns. The selected
|
||||
branch is a tinted cell moved by J / K; the caret, and with it the tinted commit, is the commit cursor
|
||||
moved by j / k
|
||||
"""
|
||||
import html
|
||||
import os
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from typing import Any, Callable, Dict, List, NamedTuple, Optional, Tuple, TypeVar
|
||||
|
||||
import sublime
|
||||
|
||||
from . import git, palette, render
|
||||
from .git import Commit, FileChange, GitError, Ref
|
||||
from .state import MODE_BRANCHES, BranchRow, ViewState
|
||||
from .utils import DEBOUNCE_MS, commits_count, file_count, run_async, status
|
||||
|
||||
# an ACTIONS entry: act(view, window, state) on the review view it fired in
|
||||
Action = Callable[[sublime.View, sublime.Window, ViewState], None]
|
||||
|
||||
# the left column: its padding after the longest cell, and the width it never exceeds
|
||||
LEFT_PAD = 2
|
||||
LEFT_MAX = 32
|
||||
# the right column: "Author: " and friends, and the bounds of its width when the viewport is odd
|
||||
LABEL_WIDTH = 13
|
||||
RIGHT_MIN = 60
|
||||
RIGHT_MAX = 200
|
||||
# a commit is its subject, author, date and stats rows, then a rule
|
||||
ROWS_PER_COMMIT = 5
|
||||
# box drawing: the column line, the rule under each item, and the column line's branch into a rule on the rule rows
|
||||
COLUMN_GAP = "│ "
|
||||
RULE = "─"
|
||||
JUNCTION = "├─"
|
||||
HEADING_BRANCHES = "BRANCHES"
|
||||
HEADING_REMOTES = "REMOTES"
|
||||
|
||||
NOT_HERE = "works in the branches view, press b"
|
||||
|
||||
# the result of a load's work, handed to its adopt step
|
||||
T = TypeVar("T")
|
||||
# a coloured part of a cell: (start, end, "del" | "ins")
|
||||
Span = Tuple[int, int, str]
|
||||
# a right-column cell: its text, the index of its item (0 the working tree, i + 1 commit i, -1 none) and its spans
|
||||
Cell = Tuple[str, int, List[Span]]
|
||||
# the right column's first item: the working tree
|
||||
WORKTREE = 0
|
||||
NO_CHANGES = "No Changes"
|
||||
# a left-column cell: its text, its branch (None for headings and remote names) and the branch's
|
||||
# standing against its upstream ("↑1 ↓2", "gone" or ""), shown right-aligned in the cell
|
||||
LeftCell = Tuple[str, Optional[Ref], str]
|
||||
|
||||
|
||||
# --- loading ----------------------------------------------------------------
|
||||
|
||||
|
||||
def _pick(refs: List[Ref], wanted: Optional[str]) -> Optional[Ref]:
|
||||
"""The branch to select: `wanted` while it exists, else the checked-out one, else the first local, else the first"""
|
||||
for ref in refs:
|
||||
if ref.name == wanted:
|
||||
return ref
|
||||
return next((r for r in refs if r.current), next((r for r in refs if r.remote is None), refs[0] if refs else None))
|
||||
|
||||
|
||||
def load(view: sublime.View, st: ViewState, message: Optional[str] = None, keep_caret: bool = False) -> None:
|
||||
"""List the branches and log the selected one off the UI thread, then draw the view
|
||||
|
||||
`message` goes to the status bar first; `keep_caret` keeps the commit cursor where it is. The diff
|
||||
state is vacated: what was shown before is not what persist records or the refresh checks any more
|
||||
"""
|
||||
if message:
|
||||
status(message)
|
||||
st.mode = MODE_BRANCHES
|
||||
st.sha = st.commit = st.change = st.requested = None
|
||||
st.lines, st.blocks, st.binary = [], [], False
|
||||
repo, wanted, count = st.repo, st.branch_ref, commits_count()
|
||||
|
||||
def work() -> Tuple[str, List[Ref], List[str], Optional[Ref], List[Commit], List[FileChange]]:
|
||||
"""HEAD's hash, the branches, the remotes, the branch to select and its log, and the working tree's changes
|
||||
|
||||
The calls that do not wait on the branch list run alongside it; only the log needs to know the branch
|
||||
"""
|
||||
with ThreadPoolExecutor(max_workers=4) as pool:
|
||||
# git status first, the slowest; the caches are warmed too, so the fingerprint after the render costs
|
||||
# no git call on the UI thread (leaving the block waits for them)
|
||||
changes, sha, remotes = pool.submit(git.changed_files, repo), pool.submit(git.head_sha, repo), pool.submit(git.remotes, repo)
|
||||
pool.submit(git.ref_paths, repo)
|
||||
git.index_path(repo)
|
||||
refs = git.branches(repo)
|
||||
ref = _pick(refs, wanted)
|
||||
commits = git.ref_log(repo, ref.name, count) if ref else []
|
||||
return sha.result(), refs, remotes.result(), ref, commits, changes.result()
|
||||
|
||||
def adopt(result: Tuple[str, List[Ref], List[str], Optional[Ref], List[Commit], List[FileChange]]) -> None:
|
||||
"""Take the listing over"""
|
||||
st.branch_head_sha, st.branch_refs, st.branch_remotes, ref, st.branch_commits, st.branch_changes = result
|
||||
st.branch_ref = ref.name if ref else None
|
||||
|
||||
_reload(view, st, work, adopt, keep_caret)
|
||||
|
||||
|
||||
def _reload(view: sublime.View, st: ViewState, work: Callable[[], T], adopt: Callable[[T], None], keep_caret: bool) -> None:
|
||||
"""Run `work` off the UI thread, then `adopt` its result and redraw, unless a later load superseded it or the view closed"""
|
||||
st.token += 1
|
||||
token = st.token
|
||||
|
||||
def done(result: T) -> None:
|
||||
"""Adopt and draw the result of the newest load only"""
|
||||
if token != st.token or not view.is_valid():
|
||||
return
|
||||
adopt(result)
|
||||
render_branches(view, st, keep_caret=keep_caret)
|
||||
st.rendered_token = token
|
||||
|
||||
run_async(work, done)
|
||||
|
||||
|
||||
def _load_log(view: sublime.View, st: ViewState) -> None:
|
||||
"""Log the selected branch off the UI thread and redraw with the cursor back on the working-tree entry"""
|
||||
repo, name, count = st.repo, st.branch_ref, commits_count()
|
||||
|
||||
def adopt(commits: List[Commit]) -> None:
|
||||
"""Take the log over"""
|
||||
st.branch_commits = commits
|
||||
|
||||
_reload(view, st, lambda: git.ref_log(repo, name, count) if name is not None else [], adopt, keep_caret=False)
|
||||
|
||||
|
||||
def load_worktree(view: sublime.View, st: ViewState) -> None:
|
||||
"""Relist the working tree's changes off the UI thread and redraw its entry; the branches and the log stand"""
|
||||
repo = st.repo
|
||||
|
||||
def adopt(changes: List[FileChange]) -> None:
|
||||
"""Take the working tree's changes over"""
|
||||
st.branch_changes = changes
|
||||
|
||||
_reload(view, st, lambda: git.changed_files(repo), adopt, keep_caret=True)
|
||||
|
||||
|
||||
def _step(view: sublime.View, position: int, count: int, delta: int) -> Optional[int]:
|
||||
"""Where a step of `delta` from `position` among `count` items lands: off them (-1) the first for a step forward
|
||||
and the last for one back; None, after a flash, past either end"""
|
||||
if position < 0:
|
||||
return 0 if delta > 0 else count - 1
|
||||
index = position + delta
|
||||
if not 0 <= index < count:
|
||||
render.flash(view)
|
||||
return None
|
||||
return index
|
||||
|
||||
|
||||
def select(view: sublime.View, st: ViewState, delta: int) -> None:
|
||||
"""Move the branch selection `delta` branches on, ringing at the ends, and log the new one
|
||||
|
||||
The cell and the header move at once; the log is fetched once the key rests, so holding J does
|
||||
not start one git process per branch passed
|
||||
"""
|
||||
# git lists the local branches before the remote ones, the order J / K step in
|
||||
names = [r.name for r in st.branch_refs]
|
||||
if not names:
|
||||
status("no branches")
|
||||
return
|
||||
position = names.index(st.branch_ref) if st.branch_ref in names else -1
|
||||
index = _step(view, position, len(names), delta)
|
||||
if index is None or index == position:
|
||||
return
|
||||
st.branch_ref = names[index]
|
||||
_paint_selection(view, st)
|
||||
render._header(view, st, header_html(st))
|
||||
st.highlight += 1
|
||||
ticket = st.highlight
|
||||
|
||||
def fetch() -> None:
|
||||
"""Load the log unless another selection came since"""
|
||||
if ticket == st.highlight and view.is_valid():
|
||||
_load_log(view, st)
|
||||
|
||||
sublime.set_timeout(fetch, DEBOUNCE_MS)
|
||||
|
||||
|
||||
# --- drawing ----------------------------------------------------------------
|
||||
|
||||
|
||||
def _standing_parts(ref: Ref) -> List[Tuple[str, str]]:
|
||||
"""How a local branch stands against its upstream, as (text, "ins" | "del") parts: ahead green, behind or gone red;
|
||||
zero counts are left out, and a level or untracked branch has none"""
|
||||
if ref.gone:
|
||||
return [("gone", "del")]
|
||||
parts = [(f"\u2191{ref.ahead}", "ins")] if ref.ahead else []
|
||||
if ref.behind:
|
||||
parts.append((f"\u2193{ref.behind}", "del"))
|
||||
return parts
|
||||
|
||||
|
||||
def _standing(ref: Ref) -> str:
|
||||
"""The standing as the left column shows it: "↑1 ↓2", "gone", or """""
|
||||
return " ".join(text for text, _ in _standing_parts(ref))
|
||||
|
||||
|
||||
def _standing_html(ref: Ref) -> str:
|
||||
"""The standing for the header, or "up to date" when there is nothing to say"""
|
||||
parts = _standing_parts(ref)
|
||||
if not parts:
|
||||
return '<span class="state">up to date</span>'
|
||||
return " ".join(f'<span class="{kind}">{text}</span>' for text, kind in parts)
|
||||
|
||||
|
||||
def _left_cells(st: ViewState) -> List[LeftCell]:
|
||||
"""(text, branch, standing) per row of the left column; headings and remote names carry no branch"""
|
||||
cells: List[LeftCell] = [(HEADING_BRANCHES, None, "")]
|
||||
for ref in st.branch_refs:
|
||||
if ref.remote is None:
|
||||
cells.append((("* " if ref.current else " ") + ref.name, ref, _standing(ref)))
|
||||
cells.append((HEADING_REMOTES, None, ""))
|
||||
# a remote keeps its row even before anything was fetched from it
|
||||
remotes = list(dict.fromkeys(list(st.branch_remotes) + [r.remote for r in st.branch_refs if r.remote]))
|
||||
for remote in remotes:
|
||||
cells.append((remote, None, ""))
|
||||
cells.extend((" " + ref.branch, ref, "") for ref in st.branch_refs if ref.remote == remote)
|
||||
return cells
|
||||
|
||||
|
||||
def _left_width(cells: List[LeftCell]) -> int:
|
||||
"""Width of the left column for its cells: the longest (with its standing and a space) plus padding, capped"""
|
||||
return min(LEFT_MAX, max(len(text) + (len(standing) + 1 if standing else 0) for text, _, standing in cells) + LEFT_PAD)
|
||||
|
||||
|
||||
def _clip(text: str, width: int) -> str:
|
||||
"""`text` cut to `width` characters with an ellipsis"""
|
||||
return text if len(text) <= width else text[: width - 1] + "\u2026"
|
||||
|
||||
|
||||
def _standing_spans(ref: Ref, width: int) -> List[Span]:
|
||||
"""The spans colouring a local branch's standing on the right edge of its cell `width` wide"""
|
||||
spans: List[Span] = []
|
||||
at = _standing_room(width, _standing(ref))
|
||||
for text, kind in _standing_parts(ref):
|
||||
spans.append((at, at + len(text), kind))
|
||||
at += len(text) + 1
|
||||
return spans
|
||||
|
||||
|
||||
def _standing_room(width: int, standing: str) -> int:
|
||||
"""Where a standing starts in a cell `width` wide: on the right edge, before the trailing space"""
|
||||
return width - 1 - len(standing)
|
||||
|
||||
|
||||
def _left_text(cell: LeftCell, width: int) -> str:
|
||||
"""The cell padded to `width` with its standing on the right edge"""
|
||||
text, _, standing = cell
|
||||
if not standing:
|
||||
return f"{_clip(text, width - 1):<{width}}"
|
||||
# the name gives way first: the counts are what the column is for
|
||||
room = _standing_room(width, standing)
|
||||
return f"{_clip(text, room - 1):<{room}}{standing} "
|
||||
|
||||
|
||||
def _right_width(view: sublime.View, left_width: int) -> int:
|
||||
"""Columns left for the right column after the left one and the gap, within sane bounds"""
|
||||
try:
|
||||
columns = int(view.viewport_extent()[0] / (view.em_width() or 8))
|
||||
except Exception:
|
||||
columns = 0
|
||||
return max(RIGHT_MIN, min(RIGHT_MAX, columns - left_width - len(COLUMN_GAP)))
|
||||
|
||||
|
||||
def _stats_cell(files: Optional[int], insertions: Optional[int], deletions: Optional[int]) -> Tuple[str, List[Span]]:
|
||||
"""A Stats row ("Stats: 3 files changed -5 +12") with the spans colouring its counts; no diffstat when `files` is None"""
|
||||
stats = f"{'Stats:':<{LABEL_WIDTH}}"
|
||||
spans: List[Span] = []
|
||||
if files is None:
|
||||
return stats + "(no diffstat)", spans
|
||||
stats += f"{file_count(files)} changed "
|
||||
dele, ins = f"-{deletions}", f"+{insertions}"
|
||||
spans.append((len(stats), len(stats) + len(dele), "del"))
|
||||
stats += dele + " "
|
||||
spans.append((len(stats), len(stats) + len(ins), "ins"))
|
||||
return stats + ins, spans
|
||||
|
||||
|
||||
def _worktree_cells(changes: List[FileChange], width: int) -> List[Cell]:
|
||||
"""The working-tree entry: the staged / unstaged file counts and their diffstat, or "No Changes", padded to five rows"""
|
||||
if not changes:
|
||||
head, stats, spans = NO_CHANGES, "", []
|
||||
else:
|
||||
stat = git.worktree_stats(changes)
|
||||
head = f"{file_count(stat.staged, 'staged')}, {file_count(stat.unstaged, 'unstaged')}"
|
||||
stats, spans = _stats_cell(stat.files, stat.insertions, stat.deletions)
|
||||
return [(head, WORKTREE, []), (stats, WORKTREE, spans), ("", WORKTREE, []), ("", WORKTREE, []), (RULE * width, WORKTREE, [])]
|
||||
|
||||
|
||||
def _right_cells(changes: List[FileChange], commits: List[Commit], width: int) -> List[Cell]:
|
||||
"""The right column: the working-tree entry, then five rows per commit, with the spans of the tags and counts to colour"""
|
||||
cells = _worktree_cells(changes, width)
|
||||
for i, c in enumerate(commits, 1):
|
||||
author = f"{'Author:':<{LABEL_WIDTH}}{c.author}"
|
||||
author_spans: List[Span] = []
|
||||
if c.tags:
|
||||
# the tags on the right edge, one space at least from the author
|
||||
tags = " ".join(c.tags)
|
||||
author = f"{author:<{max(len(author) + 1, width - len(tags))}}{tags}"
|
||||
author_spans.append((len(author) - len(tags), len(author), "ins"))
|
||||
stats, stats_spans = _stats_cell(c.files, c.insertions, c.deletions)
|
||||
cells.append((c.subject or "(no subject)", i, []))
|
||||
cells.append((author, i, author_spans))
|
||||
cells.append((f"{'Date:':<{LABEL_WIDTH}}{c.date}", i, []))
|
||||
cells.append((stats, i, stats_spans))
|
||||
cells.append((RULE * width, i, []))
|
||||
if not commits:
|
||||
cells.append(("(no commits)", -1, []))
|
||||
return cells
|
||||
|
||||
|
||||
def _item_count(st: ViewState) -> int:
|
||||
"""How many items the right column holds: the working tree and the commits"""
|
||||
return len(st.branch_commits) + 1
|
||||
|
||||
|
||||
def _caret_commit(view: sublime.View, st: ViewState) -> int:
|
||||
"""Index of the item whose rows hold the caret (WORKTREE or a commit's), -1 off them"""
|
||||
row = render.caret_index(view)
|
||||
if 0 <= row < len(st.branch_rows):
|
||||
return st.branch_rows[row].commit
|
||||
return -1
|
||||
|
||||
|
||||
class Paint(NamedTuple):
|
||||
"""What the painters need from the last render, worked out once so a j / k or J / K repaint asks Sublime nothing
|
||||
|
||||
`starts` / `ends` are each row's text points, `spans` the right column's coloured (start, end, kind) points
|
||||
per row, `standings` the left column's, and `scopes` the scope names resolved for this render
|
||||
"""
|
||||
|
||||
starts: List[int]
|
||||
ends: List[int]
|
||||
spans: List[List[Span]]
|
||||
standings: List[List[Span]]
|
||||
scopes: Dict[str, Optional[str]]
|
||||
|
||||
|
||||
def _paint(view: sublime.View, st: ViewState, rows: List[str]) -> Paint:
|
||||
"""The geometry of `rows` as drawn, and the scopes the scheme answers for now"""
|
||||
starts = render._row_starts_for_text(rows)
|
||||
spans = [[(start + a, start + b, kind) for a, b, kind in row.spans] for start, row in zip(starts, st.branch_rows)]
|
||||
standings = [[(start + a, start + b, kind) for a, b, kind in _standing_spans(row.ref, st.branch_width)]
|
||||
if row.ref is not None and row.ref.remote is None else []
|
||||
for start, row in zip(starts, st.branch_rows)]
|
||||
scopes: Dict[str, Optional[str]] = {
|
||||
"sel": render._file_header_scope(view), "cursor": palette.cursor_scope(view),
|
||||
"del": palette.text_scope(view, "del"), "ins": palette.text_scope(view, "ins"),
|
||||
"sel.del": palette.count_scope(view, "del"), "sel.ins": palette.count_scope(view, "ins"),
|
||||
"cursor.del": palette.cursor_text_scope(view, "del"), "cursor.ins": palette.cursor_text_scope(view, "ins"),
|
||||
}
|
||||
return Paint(starts, [start + len(row) for start, row in zip(starts, rows)], spans, standings, scopes)
|
||||
|
||||
|
||||
def _add(view: sublime.View, key: str, regions: List[sublime.Region], scope: Optional[str]) -> None:
|
||||
"""Fill `regions` under `key` with `scope`'s colours"""
|
||||
view.add_regions(key, regions, scope or "", flags=sublime.DRAW_NO_OUTLINE)
|
||||
|
||||
|
||||
def _paint_cursor(view: sublime.View, st: ViewState, index: int) -> None:
|
||||
"""Tint the right-column cells of item `index` (subject to stats) as the commit cursor, once the scope is live,
|
||||
and colour the counts and tags of every row: on the cursor's rows on its background, elsewhere on the editor's
|
||||
|
||||
No two regions overlap, as a region painted later repaints the text under it in its own colour. Until the
|
||||
cursor scope is live Sublime's own line highlight marks the caret row across both columns, so it stays on
|
||||
"""
|
||||
paint = st.branch_paint
|
||||
assert paint is not None
|
||||
scope = paint.scopes["cursor"]
|
||||
view.settings().set("highlight_line", scope is None)
|
||||
first, last = index * ROWS_PER_COMMIT, index * ROWS_PER_COMMIT + ROWS_PER_COMMIT - 1 # the rule row stays untinted
|
||||
cursor = scope is not None and 0 <= index < _item_count(st)
|
||||
gap = st.branch_width + len(COLUMN_GAP)
|
||||
tint: List[sublime.Region] = []
|
||||
coloured: Dict[str, List[sublime.Region]] = {"del": [], "ins": [], "cursor.del": [], "cursor.ins": []}
|
||||
for i, spans in enumerate(paint.spans):
|
||||
on_cursor = cursor and first <= i < last
|
||||
at = paint.starts[i] + gap
|
||||
for a, b, kind in spans:
|
||||
if on_cursor:
|
||||
tint.append(sublime.Region(at, a))
|
||||
coloured["cursor." + kind if on_cursor else kind].append(sublime.Region(a, b))
|
||||
at = b
|
||||
if on_cursor:
|
||||
tint.append(sublime.Region(at, paint.ends[i]))
|
||||
_add(view, render.KEY_BRANCH_DEL, coloured["del"], paint.scopes["del"])
|
||||
_add(view, render.KEY_BRANCH_INS, coloured["ins"], paint.scopes["ins"])
|
||||
if not cursor:
|
||||
for key in (render.KEY_BRANCH_CURSOR, render.KEY_BRANCH_CURSOR_DEL, render.KEY_BRANCH_CURSOR_INS):
|
||||
view.erase_regions(key)
|
||||
return
|
||||
_add(view, render.KEY_BRANCH_CURSOR, tint, scope)
|
||||
_add(view, render.KEY_BRANCH_CURSOR_DEL, coloured["cursor.del"], paint.scopes["cursor.del"])
|
||||
_add(view, render.KEY_BRANCH_CURSOR_INS, coloured["cursor.ins"], paint.scopes["cursor.ins"])
|
||||
|
||||
|
||||
def _paint_selection(view: sublime.View, st: ViewState) -> None:
|
||||
"""Tint the selected branch's cell, or nothing when none is listed, and colour the branches' standings
|
||||
|
||||
The standings are filled regions, as only those take a scope's text colour, so the selected row's
|
||||
carry its background rather than the editor's; a change of selection repaints them all
|
||||
"""
|
||||
paint = st.branch_paint
|
||||
assert paint is not None
|
||||
selected: List[sublime.Region] = []
|
||||
standings: Dict[str, List[sublime.Region]] = {"del": [], "ins": [], "sel.del": [], "sel.ins": []}
|
||||
for i, row in enumerate(st.branch_rows):
|
||||
chosen = row.ref is not None and row.ref.name == st.branch_ref
|
||||
if chosen:
|
||||
selected.append(sublime.Region(paint.starts[i], paint.starts[i] + st.branch_width))
|
||||
for a, b, kind in paint.standings[i]:
|
||||
standings["sel." + kind if chosen else kind].append(sublime.Region(a, b))
|
||||
_add(view, render.KEY_BRANCH_SEL, selected, paint.scopes["sel"])
|
||||
_add(view, render.KEY_BRANCH_STANDING_DEL, standings["del"], paint.scopes["del"])
|
||||
_add(view, render.KEY_BRANCH_STANDING_INS, standings["ins"], paint.scopes["ins"])
|
||||
_add(view, render.KEY_BRANCH_SEL_DEL, standings["sel.del"], paint.scopes["sel.del"])
|
||||
_add(view, render.KEY_BRANCH_SEL_INS, standings["sel.ins"], paint.scopes["sel.ins"])
|
||||
|
||||
|
||||
def _put_caret(view: sublime.View, st: ViewState, index: int, show: bool) -> None:
|
||||
"""Put the caret on item `index`'s first row and tint the item; `show` scrolls it into view"""
|
||||
point = render.index_point(view, index * ROWS_PER_COMMIT)
|
||||
view.sel().clear()
|
||||
view.sel().add(sublime.Region(point))
|
||||
_paint_cursor(view, st, index)
|
||||
if show:
|
||||
view.show(point)
|
||||
|
||||
|
||||
def render_branches(view: sublime.View, st: ViewState, keep_caret: bool = False) -> None:
|
||||
"""Draw the two columns, tint the selection, and put the caret on an item's first row
|
||||
|
||||
`keep_caret` leaves the cursor on the item it was on and keeps the scroll; otherwise the
|
||||
working-tree entry is the cursor and the view scrolls to the top
|
||||
"""
|
||||
commit = _caret_commit(view, st) if keep_caret else -1
|
||||
viewport = view.viewport_position() if keep_caret else (0, 0)
|
||||
# the cells of both columns, then rows of the longer column's length
|
||||
left = _left_cells(st)
|
||||
width = st.branch_width = _left_width(left)
|
||||
right_width = _right_width(view, width)
|
||||
right = _right_cells(st.branch_changes, st.branch_commits, right_width)
|
||||
rows: List[str] = []
|
||||
metadata: List[BranchRow] = []
|
||||
gap = width + len(COLUMN_GAP)
|
||||
for i in range(max(len(left), len(right))):
|
||||
left_text = _left_text(left[i], width) if i < len(left) else " " * width
|
||||
cell, index, spans = right[i] if i < len(right) else ("", -1, [])
|
||||
rows.append(left_text + (JUNCTION if cell == RULE * right_width else COLUMN_GAP) + cell)
|
||||
# the spans relative to the row's start, for the cursor painter to colour
|
||||
metadata.append(BranchRow(left[i][1] if i < len(left) else None, index, tuple((gap + a, gap + b, kind) for a, b, kind in spans)))
|
||||
st.branch_rows = metadata
|
||||
render._replace(view, "\n".join(rows))
|
||||
view.assign_syntax("scope:text.plain")
|
||||
palette.ensure(view)
|
||||
if palette.claim_restart_notice(view, palette.BRANCH_SCOPES, tokens=False):
|
||||
status(render.NEEDS_RESTART_BRANCHES)
|
||||
st.branch_paint = _paint(view, st, rows)
|
||||
# the selection and, with it, the standings; the tags and counts are painted with the cursor, by _put_caret
|
||||
_paint_selection(view, st)
|
||||
render._finish(view, st, MODE_BRANCHES, "⟐ branches", header_html(st), fingerprint)
|
||||
# the caret: on the kept item's first row, else on the working-tree entry
|
||||
if not 0 <= commit < _item_count(st):
|
||||
commit = WORKTREE
|
||||
_put_caret(view, st, commit, show=False)
|
||||
view.set_viewport_position(viewport, False)
|
||||
if keep_caret:
|
||||
view.show(render.index_point(view, commit * ROWS_PER_COMMIT))
|
||||
|
||||
|
||||
def fingerprint(st: ViewState) -> Tuple[Any, ...]:
|
||||
"""Cheap "did anything change" key: the refs' mtimes (what a checkout, commit, fetch, push or branch change
|
||||
touches), then the working-tree entry's, so a refresh can tell which half moved"""
|
||||
refs = tuple(git.mtime(path) for path in git.ref_paths(st.repo))
|
||||
return refs, render.worktree_fingerprint(st.repo, st.branch_changes)
|
||||
|
||||
|
||||
def refresh_if_changed(view: sublime.View, st: ViewState) -> None:
|
||||
"""Reload when the refs changed since the view was drawn, or relist only the working tree when only it did"""
|
||||
# not while a load is in flight: its result would only be thrown away
|
||||
if st.token != st.rendered_token:
|
||||
return
|
||||
now = fingerprint(st)
|
||||
if now == st.fingerprint:
|
||||
return
|
||||
if st.fingerprint and now[0] == st.fingerprint[0]:
|
||||
# a save, something staged: the branches and the log stand
|
||||
load_worktree(view, st)
|
||||
else:
|
||||
load(view, st, keep_caret=True)
|
||||
|
||||
|
||||
def header_html(st: ViewState) -> str:
|
||||
"""The minihtml header: the repository and HEAD, then the selected branch, its upstream and the action links"""
|
||||
current = st.current_branch()
|
||||
if current is not None:
|
||||
where = f'on <span class="hash">{html.escape(current.name)}</span>'
|
||||
elif st.branch_head_sha:
|
||||
where = f'detached at <span class="hash">{html.escape(st.branch_head_sha)}</span>'
|
||||
else:
|
||||
where = "no commits"
|
||||
summary = f'<div class="summary">Branches · {html.escape(os.path.basename(st.repo))} · {where}</div>'
|
||||
ref = st.selected_ref()
|
||||
if ref is None:
|
||||
title = '<span class="path">no branch selected</span>'
|
||||
elif ref.remote is not None:
|
||||
title = f'<span class="path">{html.escape(ref.name)}</span> <span class="when">remote branch of {html.escape(ref.remote)}</span>'
|
||||
else:
|
||||
title = f'<span class="path">{html.escape(ref.name)}</span>'
|
||||
if ref.upstream:
|
||||
title += f' <span class="when">→ {html.escape(ref.upstream)}</span> {_standing_html(ref)}'
|
||||
actions: List[str] = []
|
||||
if ref is not None:
|
||||
actions.append('<a href="checkout">Checkout</a>')
|
||||
if ref.remote is not None:
|
||||
actions.append('<a href="checkout_detached">Detached</a>')
|
||||
else:
|
||||
actions.append('<a href="pull">Pull</a>')
|
||||
actions.append('<a href="push">Push</a>')
|
||||
actions.append('<a href="fetch">Fetch</a>')
|
||||
if ref is not None and ref.remote is None:
|
||||
actions.append('<a href="delete_branch" class="danger">Delete</a>')
|
||||
return render.header_frame(summary, title, actions)
|
||||
|
||||
|
||||
# --- actions ----------------------------------------------------------------
|
||||
|
||||
|
||||
def _selected(st: ViewState, local_verb: Optional[str] = None) -> Optional[Ref]:
|
||||
"""The selected branch, with a status message when there is none; with `local_verb`, a remote one does not count either"""
|
||||
ref = st.selected_ref()
|
||||
if ref is None:
|
||||
status("no branch selected")
|
||||
elif local_verb and ref.remote is not None:
|
||||
status(f"{local_verb} works on a local branch, select one")
|
||||
return None
|
||||
return ref
|
||||
|
||||
|
||||
def _act_checkout(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Check out the selected branch; a remote one as the same-named local branch, created tracking it"""
|
||||
ref = _selected(st)
|
||||
if ref is None:
|
||||
return
|
||||
if ref.current:
|
||||
status(f"already on {ref.name}")
|
||||
return
|
||||
locals_ = [r.branch for r in st.branch_refs if r.remote is None]
|
||||
|
||||
def done(_: None) -> None:
|
||||
"""Select the branch now checked out and relist"""
|
||||
st.branch_ref = ref.branch
|
||||
load(view, st, f"checked out {ref.branch}")
|
||||
|
||||
run_async(lambda: git.checkout(st.repo, ref, locals_), done)
|
||||
|
||||
|
||||
def _act_checkout_detached(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Check out the selected remote branch with HEAD detached"""
|
||||
ref = _selected(st)
|
||||
if ref is None:
|
||||
return
|
||||
if ref.remote is None:
|
||||
status("detached checkout is for remote branches, press Enter for a local one")
|
||||
return
|
||||
run_async(lambda: git.checkout_detached(st.repo, ref.name), lambda _: load(view, st, f"checked out {ref.name} detached"))
|
||||
|
||||
|
||||
def _act_pull(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Pull the checked-out branch, or fast-forward another local branch from its upstream"""
|
||||
ref = _selected(st, "pull")
|
||||
if ref is None:
|
||||
return
|
||||
if ref.current:
|
||||
status(f"pulling {ref.name}…")
|
||||
run_async(lambda: git.pull(st.repo), lambda _: load(view, st, f"pulled {ref.name}"))
|
||||
return
|
||||
if not ref.upstream or ref.gone:
|
||||
status(f"{ref.name} has no upstream to pull from")
|
||||
return
|
||||
remote, remote_branch = ref.upstream_remote, ref.upstream_branch
|
||||
if remote is None or remote_branch is None:
|
||||
status(f"{ref.name} tracks the local branch {ref.upstream}, pull works with a remote upstream")
|
||||
return
|
||||
status(f"fast-forwarding {ref.name} from {ref.upstream}…")
|
||||
run_async(lambda: git.fetch_into(st.repo, remote, remote_branch, ref.name),
|
||||
lambda _: load(view, st, f"fast-forwarded {ref.name} to {ref.upstream}"))
|
||||
|
||||
|
||||
def _act_push(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Push the selected local branch to its upstream, or to its remote (origin by default), recording that as the upstream"""
|
||||
ref = _selected(st, "push")
|
||||
if ref is None:
|
||||
return
|
||||
if ref.upstream and not ref.gone:
|
||||
# to the upstream itself, whatever it is called there
|
||||
remote, remote_branch = ref.upstream_remote, ref.upstream_branch
|
||||
if remote is None:
|
||||
status(f"{ref.name} tracks the local branch {ref.upstream}, there is no remote to push to")
|
||||
return
|
||||
work = lambda: git.push(st.repo, remote, ref.name, remote_branch=remote_branch) # noqa: E731
|
||||
else:
|
||||
remotes = st.branch_remotes
|
||||
if not remotes:
|
||||
status("no remote to push to")
|
||||
return
|
||||
remote = "origin" if "origin" in remotes else remotes[0]
|
||||
work = lambda: git.push(st.repo, remote, ref.name, set_upstream=True) # noqa: E731
|
||||
status(f"pushing {ref.name} to {remote}…")
|
||||
run_async(work, lambda _: load(view, st, f"pushed {ref.name} to {remote}"))
|
||||
|
||||
|
||||
def _act_fetch(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Fetch every remote, pruning, and relist"""
|
||||
status("fetching all remotes…")
|
||||
run_async(lambda: git.fetch_all(st.repo), lambda _: load(view, st, "fetched all remotes", keep_caret=True))
|
||||
|
||||
|
||||
def _act_delete(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Delete the selected local branch after a confirmation; a second one forces an unmerged branch"""
|
||||
ref = _selected(st, "delete")
|
||||
if ref is None:
|
||||
return
|
||||
if ref.current:
|
||||
status(f"{ref.name} is checked out, switch away before deleting it")
|
||||
return
|
||||
if not sublime.ok_cancel_dialog(f"Delete the branch {ref.name}?", "Delete"):
|
||||
return
|
||||
|
||||
def work() -> Optional[GitError]:
|
||||
"""Delete, handing back the refusal of an unmerged branch for the second question"""
|
||||
try:
|
||||
git.delete_branch(st.repo, ref.name)
|
||||
except GitError as error:
|
||||
if "not fully merged" not in error.stderr:
|
||||
raise
|
||||
return error
|
||||
return None
|
||||
|
||||
def done(refusal: Optional[GitError]) -> None:
|
||||
"""Relist, or offer to force the deletion"""
|
||||
if refusal is None:
|
||||
load(view, st, f"deleted {ref.name}")
|
||||
return
|
||||
if sublime.ok_cancel_dialog(f"{ref.name} is not fully merged.\n\nDelete it anyway? This cannot be undone.", "Delete anyway"):
|
||||
run_async(lambda: git.delete_branch(st.repo, ref.name, force=True), lambda _: load(view, st, f"deleted {ref.name}"))
|
||||
|
||||
run_async(work, done)
|
||||
|
||||
|
||||
def _step_branch(delta: int) -> Action:
|
||||
"""Action moving the branch selection `delta` branches on"""
|
||||
def act(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Select the neighbouring branch"""
|
||||
select(view, st, delta)
|
||||
|
||||
return act
|
||||
|
||||
|
||||
def _step_commit(delta: int) -> Action:
|
||||
"""Action moving the caret `delta` items on, ringing at the ends"""
|
||||
def act(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Put the caret on the neighbouring item's first row"""
|
||||
# off the items (a left-column or blank row) j goes to the first, k to the last
|
||||
index = _step(view, _caret_commit(view, st), _item_count(st), delta)
|
||||
if index is not None:
|
||||
_put_caret(view, st, index, show=True)
|
||||
|
||||
return act
|
||||
|
||||
|
||||
def _act_open_commit(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Review the commit under the caret in the commit view, or the changed files from the working-tree entry"""
|
||||
index = _caret_commit(view, st)
|
||||
if not 0 <= index < _item_count(st):
|
||||
status("no commit under the caret")
|
||||
return
|
||||
if index == WORKTREE:
|
||||
window.run_command("vdiff_files")
|
||||
return
|
||||
window.run_command("vdiff_commits", {"sha": st.branch_commits[index - 1].sha})
|
||||
|
||||
|
||||
def _in_branches(act: Action) -> Action:
|
||||
"""`act` guarded to the branches view: header links and the popup can fire it over a diff too"""
|
||||
def guarded(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Run the action, or say where it works"""
|
||||
if st.in_branches:
|
||||
act(view, window, st)
|
||||
else:
|
||||
status(NOT_HERE)
|
||||
|
||||
return guarded
|
||||
|
||||
|
||||
ACTIONS: Dict[str, Action] = {
|
||||
name: _in_branches(act)
|
||||
for name, act in {
|
||||
"checkout": _act_checkout,
|
||||
"checkout_detached": _act_checkout_detached,
|
||||
"pull": _act_pull,
|
||||
"push": _act_push,
|
||||
"fetch": _act_fetch,
|
||||
"delete_branch": _act_delete,
|
||||
"next_branch": _step_branch(1),
|
||||
"prev_branch": _step_branch(-1),
|
||||
"next_commit": _step_commit(1),
|
||||
"prev_commit": _step_commit(-1),
|
||||
"open_commit": _act_open_commit,
|
||||
}.items()
|
||||
}
|
||||
@@ -6,10 +6,10 @@ from typing import Callable, Dict, List, Optional, Sequence, Tuple
|
||||
import sublime
|
||||
import sublime_plugin
|
||||
|
||||
from . import git, parse, render, state
|
||||
from . import branches, git, parse, render, state
|
||||
from .git import Commit, FileChange
|
||||
from .state import Kept, ViewState
|
||||
from .utils import file_count, run_async, settings, status
|
||||
from .state import MODE_BRANCHES, Kept, ViewState
|
||||
from .utils import DEBOUNCE_MS, commits_count, file_count, run_async, settings, status
|
||||
|
||||
# an ACTIONS entry: act(view, window, state) on the review view it fired in
|
||||
Action = Callable[[sublime.View, sublime.Window, ViewState], None]
|
||||
@@ -31,9 +31,6 @@ COMMIT_KIND = (sublime.KIND_ID_COLOR_BLUISH, "c", "commit")
|
||||
COMMIT_ROW_WIDTH = 120
|
||||
MIN_SUBJECT_WIDTH = 24
|
||||
|
||||
# highlight-to-preview delay: holding an arrow key must not spawn a git process per row
|
||||
PREVIEW_DELAY_MS = 60
|
||||
|
||||
# cache directory -> repo root: resolve_repo runs git on the UI thread
|
||||
_roots: Dict[str, str] = {}
|
||||
|
||||
@@ -185,6 +182,22 @@ def commit_items(commits: Sequence[Commit]) -> List[sublime.QuickPanelItem]:
|
||||
return items
|
||||
|
||||
|
||||
def redisplay(view: sublime.View, st: ViewState, keep_caret: bool = False) -> None:
|
||||
"""Redraw whatever the state describes: the branches view, all diffs, or the current file"""
|
||||
if st.in_branches:
|
||||
branches.load(view, st, keep_caret=keep_caret)
|
||||
elif st.all_mode:
|
||||
show_all(view, st)
|
||||
elif st.change is not None:
|
||||
show_file(view, st, st.change)
|
||||
|
||||
|
||||
def redisplay_if_stale(view: sublime.View, st: ViewState) -> None:
|
||||
"""Redraw when the screen shows something else than the state describes, or a render is still on its way"""
|
||||
if st.drawn != st.describe() or st.rendered_token != st.token:
|
||||
redisplay(view, st)
|
||||
|
||||
|
||||
def show_files_panel(window: sublime.Window, view: sublime.View, st: ViewState, files: List[FileChange],
|
||||
kept: Kept, on_cancel: Optional[Callable[[], None]] = None,
|
||||
placeholder: str = "Changed files") -> None:
|
||||
@@ -215,13 +228,10 @@ def show_files_panel(window: sublime.Window, view: sublime.View, st: ViewState,
|
||||
if on_cancel is not None:
|
||||
st.restore(kept)
|
||||
on_cancel()
|
||||
elif kept.change is not None:
|
||||
# reshow the kept file in the kept mode
|
||||
elif kept.mode == MODE_BRANCHES or kept.change is not None:
|
||||
# back to the branches view or the kept file in the kept mode, unless the screen still shows it
|
||||
st.restore(kept)
|
||||
if st.all_mode:
|
||||
show_all(view, st)
|
||||
else:
|
||||
show_file(view, st, kept.change)
|
||||
redisplay_if_stale(view, st)
|
||||
# nothing was kept before: the last previewed file stays
|
||||
return
|
||||
change = files[index]
|
||||
@@ -241,7 +251,7 @@ def show_files_panel(window: sublime.Window, view: sublime.View, st: ViewState,
|
||||
if ticket == st.highlight:
|
||||
show(files[index])
|
||||
|
||||
sublime.set_timeout(preview, PREVIEW_DELAY_MS)
|
||||
sublime.set_timeout(preview, DEBOUNCE_MS)
|
||||
|
||||
if st.all_mode and files:
|
||||
st.change = files[selected]
|
||||
@@ -286,11 +296,25 @@ def refresh_listing(view: sublime.View, st: ViewState, message: Optional[str] =
|
||||
|
||||
|
||||
def refresh_if_changed(view: sublime.View, st: ViewState) -> None:
|
||||
"""Re-render a working-tree view when the file or the index changed since it was drawn"""
|
||||
"""Re-render a working-tree view when a shown file, the index or the list of changed files moved since it was drawn;
|
||||
the branches view keeps its own check"""
|
||||
if st.in_branches:
|
||||
branches.refresh_if_changed(view, st)
|
||||
return
|
||||
if st.in_commit or st.change is None:
|
||||
return
|
||||
if render.fingerprint(st) != st.fingerprint:
|
||||
refresh_listing(view, st)
|
||||
return
|
||||
# the mtimes watch only the listed files; git status, off the UI thread, sees a file newly changed outside the list
|
||||
token = st.token
|
||||
|
||||
def done(files: List[FileChange]) -> None:
|
||||
"""Re-list when the working tree's changes are no longer the listed ones, unless a newer render took over"""
|
||||
if view.is_valid() and token == st.token and files != st.files:
|
||||
refresh_listing(view, st)
|
||||
|
||||
run_async(lambda: git.changed_files(st.repo), done)
|
||||
|
||||
|
||||
class VdiffFilesCommand(sublime_plugin.WindowCommand):
|
||||
@@ -308,6 +332,10 @@ class VdiffFilesCommand(sublime_plugin.WindowCommand):
|
||||
"""Show the files panel, or a notice when there is nothing uncommitted"""
|
||||
if not view.is_valid():
|
||||
return
|
||||
if not files and (st.in_branches or st.in_commit):
|
||||
# the notice would replace a view that still holds: the branches, or a commit under review
|
||||
status("no uncommitted changes")
|
||||
return
|
||||
kept = st.enter()
|
||||
if not files:
|
||||
render.render_message(view, st, f"No uncommitted changes in {st.repo}")
|
||||
@@ -331,7 +359,7 @@ class VdiffCommitsCommand(sublime_plugin.WindowCommand):
|
||||
if sha:
|
||||
self.open_commit(view, st, sha, None)
|
||||
return
|
||||
count = int(settings().get("commits_count", 30) or 30)
|
||||
count = commits_count()
|
||||
|
||||
def done(commits: List[Commit]) -> None:
|
||||
"""Show the commits panel unless the repository has none"""
|
||||
@@ -352,9 +380,12 @@ class VdiffCommitsCommand(sublime_plugin.WindowCommand):
|
||||
selected = i
|
||||
|
||||
def on_select(index: int) -> None:
|
||||
"""Open the chosen commit's files, remembering its row for Esc"""
|
||||
"""Open the chosen commit's files, remembering its row for Esc; Esc itself redraws what the state went
|
||||
back to when the list was reopened from a commit's files, whose diff is still on screen"""
|
||||
if index != -1:
|
||||
self.open_commit(view, st, commits[index].sha, index)
|
||||
else:
|
||||
redisplay_if_stale(view, st)
|
||||
|
||||
self.window.show_quick_panel(items, on_select, 0, selected, None, "Recent commits")
|
||||
|
||||
@@ -383,6 +414,16 @@ class VdiffCommitsCommand(sublime_plugin.WindowCommand):
|
||||
run_async(lambda: git.commit_with_files(st.repo, sha), done)
|
||||
|
||||
|
||||
class VdiffBranchesCommand(sublime_plugin.WindowCommand):
|
||||
"""Show the branches view: local branches and remotes, and the log of the selected one"""
|
||||
|
||||
def run(self) -> None:
|
||||
"""Open the review view and list the branches off the UI thread"""
|
||||
opened = open_review(self.window)
|
||||
if opened:
|
||||
branches.load(*opened)
|
||||
|
||||
|
||||
# --- review view actions ----------------------------------------------------
|
||||
|
||||
|
||||
@@ -396,6 +437,11 @@ def _act_commits(view: sublime.View, window: sublime.Window, st: ViewState) -> N
|
||||
window.run_command("vdiff_commits")
|
||||
|
||||
|
||||
def _act_branches(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Show (or reload) the branches view"""
|
||||
window.run_command("vdiff_branches")
|
||||
|
||||
|
||||
def _act_close(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Close the review view"""
|
||||
view.close()
|
||||
@@ -414,9 +460,12 @@ def _git_action(verb: str, done_verb: str, operation: Callable[[str, FileChange]
|
||||
def act(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Confirm if asked, run the operation off the UI thread, then refresh the listing"""
|
||||
change = _current_change(view, st)
|
||||
if st.in_commit or change is None:
|
||||
if st.in_commit:
|
||||
status(f"{verb} works on uncommitted changes only")
|
||||
return
|
||||
if change is None:
|
||||
status("no file under the caret")
|
||||
return
|
||||
if confirm is not None and not confirm(change):
|
||||
return
|
||||
run_async(
|
||||
@@ -464,10 +513,10 @@ def _confirm_discard(change: FileChange) -> bool:
|
||||
|
||||
|
||||
def _next_unstaged(files: Sequence[FileChange], start: int) -> int:
|
||||
"""Index of the first unstaged file from `start` on, wrapping round; -1 when every file is staged"""
|
||||
"""Index of the first file with something to stage from `start` on, wrapping round; -1 when everything is staged"""
|
||||
for offset in range(len(files)):
|
||||
index = (start + offset) % len(files)
|
||||
if not files[index].staged:
|
||||
if files[index].has_unstaged:
|
||||
return index
|
||||
return -1
|
||||
|
||||
@@ -482,24 +531,20 @@ def _stage_next(files: Sequence[FileChange], index: int) -> Optional[FileChange]
|
||||
|
||||
|
||||
def _act_refresh(view: sublime.View, window: sublime.Window, st: ViewState) -> None:
|
||||
"""Reload what is shown: all diffs, the commit's file, or the working-tree listing"""
|
||||
if st.all_mode:
|
||||
show_all(view, st)
|
||||
return
|
||||
if st.change is None:
|
||||
return
|
||||
if st.in_commit:
|
||||
show_file(view, st, st.change)
|
||||
else:
|
||||
"""Reload what is shown: the branches, the commit's diffs, or the working tree re-listed (new and reverted files too)"""
|
||||
if st.in_branches or st.in_commit:
|
||||
redisplay(view, st, keep_caret=True)
|
||||
elif st.all_mode or st.change is not None:
|
||||
refresh_listing(view, st)
|
||||
|
||||
|
||||
def _current_change(view: sublime.View, st: ViewState) -> Optional[FileChange]:
|
||||
"""File under the caret in the aggregate view (made current), else the shown file"""
|
||||
"""File under the caret in the aggregate view (made current), None on a blank row or the top row; else the shown file"""
|
||||
if st.all_mode:
|
||||
change = render.all_change_at(view, st)
|
||||
if change is not None:
|
||||
st.change = change
|
||||
return change
|
||||
return st.change
|
||||
|
||||
|
||||
@@ -507,6 +552,7 @@ def _act_open(view: sublime.View, window: sublime.Window, st: ViewState) -> None
|
||||
"""Open the working-tree file at the line under the caret"""
|
||||
change = _current_change(view, st)
|
||||
if change is None:
|
||||
status("no file under the caret")
|
||||
return
|
||||
path = os.path.join(st.repo, change.path)
|
||||
if not os.path.exists(path):
|
||||
@@ -516,7 +562,10 @@ def _act_open(view: sublime.View, window: sublime.Window, st: ViewState) -> None
|
||||
if st.all_mode:
|
||||
row = render.caret_index(view)
|
||||
displayed = st.all_rows[row][1] if 0 <= row < len(st.all_rows) else None
|
||||
line = displayed.new_no if displayed and displayed.new_no is not None else 1
|
||||
# the row's slot in the file's whole diff (a heading is its start), mapped as the single-file view maps it
|
||||
lines = st.all_diffs.get(change.path, ([], [], False))[0]
|
||||
index = next((i for i, line in enumerate(lines) if line is displayed), 0)
|
||||
line = parse.line_for_open(lines, index)
|
||||
else:
|
||||
line = parse.line_for_open(st.lines, render.caret_index(view))
|
||||
window.open_file(f"{path}:{line}", sublime.ENCODED_POSITION)
|
||||
@@ -565,9 +614,13 @@ def _step_file(delta: int) -> Action:
|
||||
status("no files to step through")
|
||||
return
|
||||
change = _current_change(view, st)
|
||||
index = state.find_change(st.files, change.path if change else None)
|
||||
# nothing selected yet: n starts at the first file, p at the last
|
||||
index = (index + delta) % len(st.files) if index >= 0 else (0 if delta > 0 else len(st.files) - 1)
|
||||
if change is not None:
|
||||
index = (state.find_change(st.files, change.path) + delta) % len(st.files)
|
||||
else:
|
||||
# a blank row or the top row sits above a file: n goes to that file, p to the one before it
|
||||
below = render.all_change_below(view, st)
|
||||
index = state.find_change(st.files, below.path) if below else 0
|
||||
index = (index if delta > 0 else index - 1) % len(st.files)
|
||||
st.change = st.files[index]
|
||||
st.collapsed.discard(st.change.path)
|
||||
render.render_all(view, st, focus=st.change.path, center=True)
|
||||
@@ -600,7 +653,8 @@ def _step_change(delta: int) -> Action:
|
||||
"""Jump to the next or previous change, across files in the aggregate view"""
|
||||
if st.all_mode:
|
||||
# aggregate view: the hunks of all files are the targets
|
||||
current_change = _current_change(view, st)
|
||||
# a blank row or the top row counts as above the file below it: ] goes to its first hunk, [ before it
|
||||
current_change = _current_change(view, st) or render.all_change_below(view, st)
|
||||
rows = st.all_change_rows
|
||||
targets = st.all_change_targets
|
||||
if not targets:
|
||||
@@ -720,11 +774,12 @@ def _move_line(forward: bool) -> Action:
|
||||
ACTIONS: Dict[str, Action] = {
|
||||
"files": _act_files,
|
||||
"commits": _act_commits,
|
||||
"branches": _act_branches,
|
||||
"close": _act_close,
|
||||
"help": _act_help,
|
||||
"stage": _git_action("stage", "staged", git.stage, pick=_stage_next),
|
||||
"unstage": _git_action("unstage", "unstaged", git.unstage),
|
||||
"stage_all": _bulk_action("stage", "staged", git.stage_all, lambda c: not c.staged),
|
||||
"stage_all": _bulk_action("stage", "staged", git.stage_all, lambda c: c.has_unstaged),
|
||||
"unstage_all": _bulk_action("unstage", "unstaged", git.unstage_all, lambda c: c.staged),
|
||||
"discard": _git_action("discard", "discarded", git.discard, confirm=_confirm_discard),
|
||||
"commit": _act_commit,
|
||||
@@ -742,6 +797,8 @@ ACTIONS: Dict[str, Action] = {
|
||||
"line_down": _move_line(True),
|
||||
"line_up": _move_line(False),
|
||||
}
|
||||
# the branches view's actions: the keymap reaches them through the vdiff_mode context
|
||||
ACTIONS.update(branches.ACTIONS)
|
||||
|
||||
|
||||
class VdiffActionCommand(sublime_plugin.TextCommand):
|
||||
@@ -766,18 +823,24 @@ def restore_view(view: sublime.View) -> ViewState:
|
||||
# the repo, commit and file saved with the view
|
||||
data = view.settings().get(state.VIEW_DATA) or {}
|
||||
repo = data.get("repo")
|
||||
render.init_view(view)
|
||||
mode = data.get("mode") or state.MODE_DIFF
|
||||
render.init_view(view, mode)
|
||||
# repository gone: show a notice
|
||||
if not repo or not os.path.isdir(repo):
|
||||
st = state.put(view, state.ViewState(""))
|
||||
render.render_message(view, st, "Repository not found. Press f for changed files, c for commits.")
|
||||
render.render_message(view, st, "Repository not found. Press f for changed files, c for commits, b for branches.")
|
||||
return st
|
||||
st = state.put(view, state.ViewState(repo))
|
||||
st.sha = data.get("sha")
|
||||
st.all_mode = bool(data.get("all_mode", False))
|
||||
# the branches view comes back on the same branch
|
||||
if mode == MODE_BRANCHES:
|
||||
st.mode, st.branch_ref = mode, data.get("ref")
|
||||
redisplay(view, st)
|
||||
return st
|
||||
path = data.get("path")
|
||||
if not path:
|
||||
render.render_message(view, st, "Press f for changed files, c for commits.")
|
||||
render.render_message(view, st, "Press f for changed files, c for commits, b for branches.")
|
||||
return st
|
||||
# stand-in FileChange: no line counts or rename source
|
||||
change = git.FileChange(path, data.get("status", "M"), bool(data.get("staged")), None, None, None)
|
||||
@@ -788,28 +851,20 @@ def restore_view(view: sublime.View) -> ViewState:
|
||||
|
||||
def show_commit(result: Tuple[git.CommitInfo, List[FileChange]]) -> None:
|
||||
"""Adopt the commit's files and redraw the saved file or the aggregate view"""
|
||||
st.commit, st.files = result
|
||||
if st.all_mode:
|
||||
st.change = change
|
||||
show_all(view, st)
|
||||
else:
|
||||
show_file(view, st, change)
|
||||
st.commit, st.files, st.change = result[0], result[1], change
|
||||
redisplay(view, st)
|
||||
|
||||
run_async(lambda: git.commit_with_files(repo, sha), show_commit)
|
||||
else:
|
||||
|
||||
def show_working_tree(files: List[FileChange]) -> None:
|
||||
"""Redraw the saved file if it still has changes, else say it has none"""
|
||||
"""Redraw the saved file, or the first changed one when it has no changes any more"""
|
||||
st.files = files
|
||||
index = state.find_change(files, path)
|
||||
if index >= 0:
|
||||
if st.all_mode:
|
||||
st.change = files[index]
|
||||
show_all(view, st)
|
||||
else:
|
||||
show_file(view, st, files[index])
|
||||
else:
|
||||
render.render_message(view, st, f"{path} has no uncommitted changes any more")
|
||||
if not files:
|
||||
render.render_message(view, st, f"No uncommitted changes in {repo}")
|
||||
return
|
||||
st.change = files[max(0, state.find_change(files, path))]
|
||||
redisplay(view, st)
|
||||
|
||||
run_async(lambda: git.changed_files(repo), show_working_tree)
|
||||
return st
|
||||
|
||||
281
vdiff/git.py
281
vdiff/git.py
@@ -7,7 +7,11 @@ from typing import Dict, List, Optional, NamedTuple, Sequence, Tuple
|
||||
|
||||
|
||||
class FileChange(NamedTuple):
|
||||
"""Path, one-letter status (see STATUS_NAMES), staged flag, numstat counts (None for binary), rename source"""
|
||||
"""Path, one-letter status (see STATUS_NAMES), staged flag, numstat counts (None for binary), rename source
|
||||
|
||||
`staged` means something of the file is in the index, `unstaged` that the working tree differs from the
|
||||
index (an untracked file is unstaged); a partially staged file carries both
|
||||
"""
|
||||
|
||||
path: str
|
||||
status: str
|
||||
@@ -15,10 +19,35 @@ class FileChange(NamedTuple):
|
||||
insertions: Optional[int]
|
||||
deletions: Optional[int]
|
||||
old_path: Optional[str]
|
||||
unstaged: bool = False
|
||||
|
||||
@property
|
||||
def has_unstaged(self) -> bool:
|
||||
"""Whether something of the file is left to stage: a file with nothing staged is, whatever its flag says"""
|
||||
return self.unstaged or not self.staged
|
||||
|
||||
|
||||
class WorkTree(NamedTuple):
|
||||
"""The working tree's changes summed up: how many files are staged / unstaged, and the diffstat of them all"""
|
||||
|
||||
staged: int
|
||||
unstaged: int
|
||||
files: int
|
||||
insertions: int
|
||||
deletions: int
|
||||
|
||||
|
||||
def worktree_stats(changes: Sequence[FileChange]) -> WorkTree:
|
||||
"""Sum the working tree listing: a partially staged file counts on both sides; binary files carry None counts and add nothing"""
|
||||
return WorkTree(sum(1 for c in changes if c.staged), sum(1 for c in changes if c.has_unstaged), len(changes),
|
||||
sum(c.insertions or 0 for c in changes), sum(c.deletions or 0 for c in changes))
|
||||
|
||||
|
||||
class Commit(NamedTuple):
|
||||
"""One log entry, date relative; files/insertions/deletions are None without a diffstat (merges, empty commits)"""
|
||||
"""One log entry; files/insertions/deletions are None without a diffstat (merges, empty commits)
|
||||
|
||||
`date` is relative from recent_commits and dd.mm.yyyy from ref_log, which is also what fills `tags`
|
||||
"""
|
||||
|
||||
sha: str
|
||||
short: str
|
||||
@@ -28,6 +57,34 @@ class Commit(NamedTuple):
|
||||
files: Optional[int]
|
||||
insertions: Optional[int]
|
||||
deletions: Optional[int]
|
||||
tags: Tuple[str, ...] = ()
|
||||
|
||||
|
||||
class Ref(NamedTuple):
|
||||
"""One local or remote branch
|
||||
|
||||
`name` is what git calls it ("main", "origin/main"), `branch` the part after the remote; ahead/behind
|
||||
count against the upstream, `gone` says the upstream was deleted. `upstream_remote` is the remote the
|
||||
upstream lives on, None without an upstream or when it is a local branch
|
||||
"""
|
||||
|
||||
name: str
|
||||
branch: str
|
||||
remote: Optional[str]
|
||||
sha: str
|
||||
upstream: Optional[str]
|
||||
ahead: int
|
||||
behind: int
|
||||
gone: bool
|
||||
current: bool
|
||||
upstream_remote: Optional[str] = None
|
||||
|
||||
@property
|
||||
def upstream_branch(self) -> Optional[str]:
|
||||
"""The upstream's name on its remote ("bar" for origin/bar), None without a remote upstream"""
|
||||
if self.upstream and self.upstream_remote:
|
||||
return self.upstream[len(self.upstream_remote) + 1:]
|
||||
return None
|
||||
|
||||
|
||||
class CommitInfo(NamedTuple):
|
||||
@@ -53,6 +110,23 @@ FULL_CONTEXT = "-U999999"
|
||||
# overridable from settings (sublime's PATH may not have a user-installed git)
|
||||
GIT_BINARY: str = "git"
|
||||
|
||||
# environment of the network commands: no terminal to answer a credential prompt or edit a merge
|
||||
# message in, so git fails fast instead of hanging the worker thread
|
||||
NO_PROMPT: Dict[str, str] = {"GIT_TERMINAL_PROMPT": "0", "GIT_EDITOR": "true"}
|
||||
# git's messages in English whatever the user's locale: delete_branch's refusal is told apart by its text
|
||||
PLAIN_MESSAGES: Dict[str, str] = {"LC_ALL": "C", "LANGUAGE": "C"}
|
||||
|
||||
# the ref namespaces listed by branches(); remotes carry a symbolic HEAD that is skipped
|
||||
_HEADS = "refs/heads/"
|
||||
_REMOTES = "refs/remotes/"
|
||||
# for-each-ref knows no %x1f escape, so the separator goes in literally
|
||||
_REF_FORMAT = "\x1f".join(("%(refname)", "%(objectname:short)", "%(upstream:short)", "%(upstream:track,nobracket)", "%(HEAD)",
|
||||
"%(symref)", "%(upstream:remotename)"))
|
||||
# sha, short, author, date (as --date says), subject and the decorations the tags are read from
|
||||
_LOG_FORMAT = "--format=%H%x1f%h%x1f%an%x1f%ad%x1f%s%x1f%D"
|
||||
_RELATIVE_DATE = "--date=relative"
|
||||
_DAY_DATE = "--date=format:%d.%m.%Y"
|
||||
|
||||
STATUS_NAMES: Dict[str, str] = {
|
||||
"M": "modified",
|
||||
"A": "added",
|
||||
@@ -82,10 +156,15 @@ class GitError(Exception):
|
||||
super().__init__(first[0] if first else f"git exited with {code}")
|
||||
|
||||
|
||||
def run(repo: str, args: Sequence[str], ok_codes: Tuple[int, ...] = (0,)) -> str:
|
||||
"""Run git in `repo`, return stdout as text"""
|
||||
def run(repo: str, args: Sequence[str], ok_codes: Tuple[int, ...] = (0,), env: Optional[Dict[str, str]] = None) -> str:
|
||||
"""Run git in `repo`, return stdout as text; `env` adds to or overrides the inherited environment
|
||||
|
||||
stdin is closed: nothing git or its helpers could ask would get an answer from the worker thread
|
||||
"""
|
||||
cmd = [GIT_BINARY, "-c", "core.quotepath=off", "--no-pager"] + list(args)
|
||||
proc = subprocess.run(cmd, cwd=repo, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding="utf-8", errors="replace")
|
||||
environment = dict(os.environ, **PLAIN_MESSAGES, **(env or {}))
|
||||
proc = subprocess.run(cmd, cwd=repo, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
||||
encoding="utf-8", errors="replace", env=environment)
|
||||
if proc.returncode not in ok_codes:
|
||||
raise GitError(proc.stderr, proc.returncode)
|
||||
return proc.stdout
|
||||
@@ -117,17 +196,70 @@ def has_head(repo: str) -> bool:
|
||||
|
||||
|
||||
@functools.lru_cache(maxsize=None)
|
||||
def index_path(repo: str) -> Optional[str]:
|
||||
"""Absolute path of the repository's index file, None outside a repository
|
||||
def _git_paths(repo: str, names: Tuple[str, ...]) -> Tuple[str, ...]:
|
||||
"""Absolute paths of files of the repository's git directory, () outside a repository
|
||||
|
||||
A worktree or submodule keeps it outside <repo>/.git, which there is a file, not a directory
|
||||
A worktree or submodule keeps them outside <repo>/.git, which there is a file, not a directory
|
||||
"""
|
||||
try:
|
||||
return os.path.join(repo, run(repo, ["rev-parse", "--git-path", "index"]).strip())
|
||||
# one --git-path per name, answered one per line
|
||||
text = run(repo, ["rev-parse"] + [arg for name in names for arg in ("--git-path", name)])
|
||||
except (GitError, OSError):
|
||||
return ()
|
||||
return tuple(os.path.join(repo, line) for line in text.split("\n") if line)
|
||||
|
||||
|
||||
def index_path(repo: str) -> Optional[str]:
|
||||
"""Absolute path of the repository's index file, None outside a repository"""
|
||||
paths = _git_paths(repo, ("index",))
|
||||
return paths[0] if paths else None
|
||||
|
||||
|
||||
# what any checkout, commit, fetch, push or branch change touches: refs are written through a lock-file
|
||||
# rename (bumping the directory's mtime) and every HEAD move appends to logs/HEAD
|
||||
REF_PATH_NAMES: Tuple[str, ...] = ("HEAD", "logs/HEAD", "packed-refs", "FETCH_HEAD", "refs/heads", "refs/remotes")
|
||||
REF_DIRS: Tuple[str, ...] = ("refs/heads", "refs/remotes")
|
||||
|
||||
|
||||
# {repo: (the ref directories walked, roots first, and their mtimes then)}: a directory's mtime moves when an
|
||||
# entry is added to or removed from it, so the walk is only redone when one of them moved
|
||||
_nested_refs: Dict[str, Tuple[Tuple[str, ...], Tuple[Optional[float], ...]]] = {}
|
||||
|
||||
|
||||
def mtime(path: str) -> Optional[float]:
|
||||
"""A file's or directory's mtime, None when it is gone"""
|
||||
try:
|
||||
return os.stat(path).st_mtime
|
||||
except OSError:
|
||||
return None
|
||||
|
||||
|
||||
def ref_paths(repo: str) -> Tuple[str, ...]:
|
||||
"""Absolute paths whose mtimes change when the branches do; () outside a repository
|
||||
|
||||
REF_PATH_NAMES, then every directory below the ref directories: a ref's rename bumps only the directory
|
||||
it is in, and remote-tracking refs and slashed branches live one or more levels down
|
||||
"""
|
||||
paths = _git_paths(repo, REF_PATH_NAMES)
|
||||
if not paths:
|
||||
return paths
|
||||
roots = tuple(paths[REF_PATH_NAMES.index(name)] for name in REF_DIRS)
|
||||
cached = _nested_refs.get(repo)
|
||||
if cached is not None:
|
||||
walked, mtimes = cached
|
||||
if tuple(mtime(d) for d in walked) == mtimes:
|
||||
return paths + walked[len(roots):]
|
||||
found: List[str] = []
|
||||
for root in roots:
|
||||
for directory, dirs, _ in os.walk(root):
|
||||
dirs.sort()
|
||||
if directory != root:
|
||||
found.append(directory)
|
||||
walked = roots + tuple(found)
|
||||
_nested_refs[repo] = (walked, tuple(mtime(d) for d in walked))
|
||||
return paths + tuple(found)
|
||||
|
||||
|
||||
def base_ref(repo: str) -> str:
|
||||
"""HEAD, or the empty tree when there is no commit yet"""
|
||||
return "HEAD" if has_head(repo) else EMPTY_TREE
|
||||
@@ -219,9 +351,9 @@ def changed_files(repo: str) -> List[FileChange]:
|
||||
xy, path = ".?", entry[2:]
|
||||
else:
|
||||
continue
|
||||
# any index change means staged; the worktree letter wins over the index letter
|
||||
# any index change means staged, any worktree one unstaged; the worktree letter wins over the index letter
|
||||
x, y = xy[0], xy[1]
|
||||
staged = x not in (".", "?")
|
||||
staged, unstaged = x not in (".", "?"), y != "."
|
||||
letter = y if y != "." else x
|
||||
# untracked files have no numstat: their lines count as insertions
|
||||
if letter == "?":
|
||||
@@ -229,24 +361,24 @@ def changed_files(repo: str) -> List[FileChange]:
|
||||
ins, dele, old = lines, (None if lines is None else 0), None
|
||||
else:
|
||||
ins, dele, old = counts.get(path, (0, 0, None))
|
||||
changes.append(FileChange(path, letter, staged, ins, dele, old))
|
||||
changes.append(FileChange(path, letter, staged, ins, dele, old, unstaged))
|
||||
changes.sort(key=lambda c: c.path)
|
||||
return changes
|
||||
|
||||
|
||||
def recent_commits(repo: str, count: int) -> List[Commit]:
|
||||
"""Last `count` commits, newest first; empty list without commits"""
|
||||
if not has_head(repo):
|
||||
return []
|
||||
# --shortstat adds per-commit totals to the same call
|
||||
text = run(repo, ["log", "-n", str(count), "--format=%H%x1f%h%x1f%an%x1f%ar%x1f%s", "--shortstat"])
|
||||
# a five-field line starts a commit; the shortstat line after it fills in its totals
|
||||
def _log(repo: str, args: Sequence[str]) -> List[Commit]:
|
||||
"""`log <args>` in _LOG_FORMAT with --shortstat -> commits, newest first
|
||||
|
||||
A six-field line starts a commit (its tags come from the %D decoration list); the shortstat line
|
||||
after it fills in its totals
|
||||
"""
|
||||
commits: List[Commit] = []
|
||||
for line in text.split("\n"):
|
||||
for line in run(repo, ["log", _LOG_FORMAT, "--shortstat"] + list(args)).split("\n"):
|
||||
parts = line.split("\x1f")
|
||||
if len(parts) == 5:
|
||||
sha, short, author, date, subject = parts
|
||||
commits.append(Commit(sha, short, author, date, subject, files=None, insertions=None, deletions=None))
|
||||
if len(parts) == 6:
|
||||
sha, short, author, date, subject, decorations = parts
|
||||
tags = tuple(d[5:] for d in decorations.split(", ") if d.startswith("tag: "))
|
||||
commits.append(Commit(sha, short, author, date, subject, None, None, None, tags))
|
||||
continue
|
||||
if commits and commits[-1].files is None:
|
||||
stat = _SHORTSTAT.match(line)
|
||||
@@ -256,6 +388,109 @@ def recent_commits(repo: str, count: int) -> List[Commit]:
|
||||
return commits
|
||||
|
||||
|
||||
def recent_commits(repo: str, count: int) -> List[Commit]:
|
||||
"""Last `count` commits, newest first, dates relative; empty list without commits"""
|
||||
if not has_head(repo):
|
||||
return []
|
||||
return _log(repo, ["-n", str(count), _RELATIVE_DATE])
|
||||
|
||||
|
||||
def ref_log(repo: str, ref: str, count: int) -> List[Commit]:
|
||||
"""Last `count` commits reachable from `ref`, newest first, with dd.mm.yyyy dates"""
|
||||
return _log(repo, [ref, "-n", str(count), _DAY_DATE, "--"])
|
||||
|
||||
|
||||
# --- branches ---------------------------------------------------------------
|
||||
|
||||
|
||||
def remotes(repo: str) -> List[str]:
|
||||
"""Configured remote names, fetched or not"""
|
||||
return [line for line in run(repo, ["remote"]).split("\n") if line]
|
||||
|
||||
|
||||
def head_sha(repo: str) -> str:
|
||||
"""HEAD's short hash, "" before the first commit; which branch it is on, if any, branches() marks"""
|
||||
# -q --verify: exit 1 and no output without a commit
|
||||
return run(repo, ["rev-parse", "-q", "--verify", "--short", "HEAD"], ok_codes=(0, 1)).strip()
|
||||
|
||||
|
||||
def _track(text: str) -> Tuple[int, int, bool]:
|
||||
"""`%(upstream:track,nobracket)` -> (ahead, behind, gone)"""
|
||||
ahead = re.search(r"ahead (\d+)", text)
|
||||
behind = re.search(r"behind (\d+)", text)
|
||||
return int(ahead.group(1)) if ahead else 0, int(behind.group(1)) if behind else 0, text.strip() == "gone"
|
||||
|
||||
|
||||
def branches(repo: str) -> List[Ref]:
|
||||
"""Local branches, then remote ones, in git's ref order; a remote's symbolic HEAD is left out"""
|
||||
refs: List[Ref] = []
|
||||
for line in run(repo, ["for-each-ref", f"--format={_REF_FORMAT}", _HEADS, _REMOTES]).split("\n"):
|
||||
parts = line.split("\x1f")
|
||||
if len(parts) != 7:
|
||||
continue
|
||||
refname, sha, upstream, track, marker, symref, remotename = parts
|
||||
if symref:
|
||||
continue
|
||||
ahead, behind, gone = _track(track)
|
||||
if refname.startswith(_HEADS):
|
||||
name = refname[len(_HEADS):]
|
||||
# "." is git's name for the local repository: an upstream that is a local branch
|
||||
upstream_remote = remotename if upstream and remotename != "." else None
|
||||
refs.append(Ref(name, name, None, sha, upstream or None, ahead, behind, gone, marker == "*", upstream_remote))
|
||||
elif refname.startswith(_REMOTES):
|
||||
name = refname[len(_REMOTES):]
|
||||
# the remote is the first path segment; a remote named with a slash is not supported
|
||||
remote, _, branch = name.partition("/")
|
||||
refs.append(Ref(name, branch, remote, sha, None, 0, 0, False, False))
|
||||
return refs
|
||||
|
||||
|
||||
def checkout(repo: str, ref: Ref, local_names: Sequence[str] = ()) -> None:
|
||||
"""Check out a local branch, or a remote one as a same-named local branch tracking it
|
||||
|
||||
An existing local branch of that name is checked out as it is. The remote is named explicitly:
|
||||
git's own guess fails when two remotes carry the branch
|
||||
"""
|
||||
if ref.remote is None or ref.branch in local_names:
|
||||
run(repo, ["checkout", "-q", ref.branch, "--"])
|
||||
else:
|
||||
run(repo, ["checkout", "-q", "--track", f"{ref.remote}/{ref.branch}", "--"])
|
||||
|
||||
|
||||
def checkout_detached(repo: str, name: str) -> None:
|
||||
"""Check out `name` (a remote branch, say) with HEAD detached"""
|
||||
run(repo, ["checkout", "-q", "--detach", name, "--"])
|
||||
|
||||
|
||||
def pull(repo: str) -> None:
|
||||
"""Pull the current branch from its upstream, as the user's pull.* configuration says"""
|
||||
run(repo, ["pull", "-q"], env=NO_PROMPT)
|
||||
|
||||
|
||||
def fetch_into(repo: str, remote: str, remote_branch: str, branch: str) -> None:
|
||||
"""Fast-forward the local `branch` to `remote`'s `remote_branch` without checking it out
|
||||
|
||||
git refuses a non-fast-forward update and a branch that is checked out, which the error says
|
||||
"""
|
||||
run(repo, ["fetch", "-q", remote, f"{remote_branch}:{branch}"], env=NO_PROMPT)
|
||||
|
||||
|
||||
def push(repo: str, remote: str, branch: str, set_upstream: bool = False, remote_branch: Optional[str] = None) -> None:
|
||||
"""Push `branch` to `remote`, as `remote_branch` there when that differs, recording it as the upstream when asked"""
|
||||
refspec = f"{branch}:{remote_branch}" if remote_branch else branch
|
||||
run(repo, ["push", "-q"] + (["-u"] if set_upstream else []) + [remote, refspec], env=NO_PROMPT)
|
||||
|
||||
|
||||
def fetch_all(repo: str) -> None:
|
||||
"""Fetch every remote, dropping remote branches that no longer exist"""
|
||||
run(repo, ["fetch", "-q", "--all", "--prune"], env=NO_PROMPT)
|
||||
|
||||
|
||||
def delete_branch(repo: str, branch: str, force: bool = False) -> None:
|
||||
"""Delete a local branch; without `force` git refuses one that is not fully merged ("not fully merged" in stderr)"""
|
||||
run(repo, ["branch", "-D" if force else "-d", branch])
|
||||
|
||||
|
||||
def commit_with_files(repo: str, sha: str) -> Tuple[CommitInfo, List[FileChange]]:
|
||||
"""(CommitInfo, [FileChange]) of one commit vs its first parent, files sorted by path; two git calls"""
|
||||
show = ["show", "--first-parent", "-m", "-z"]
|
||||
|
||||
@@ -1,10 +1,15 @@
|
||||
"""Event listener: state cleanup, refresh when the tab comes back or a file is saved"""
|
||||
"""Event listener: state cleanup, refresh when the tab comes back or a file is saved, the keymap's mode context"""
|
||||
from typing import Optional
|
||||
|
||||
import sublime
|
||||
import sublime_plugin
|
||||
|
||||
from . import state
|
||||
from . import render, state
|
||||
from .commands import refresh_if_changed, restore_view
|
||||
|
||||
# the keymap context naming the review view's mode; a setting context would not compare strings reliably
|
||||
MODE_CONTEXT = "vdiff_mode"
|
||||
|
||||
|
||||
class VdiffEventListener(sublime_plugin.EventListener):
|
||||
def on_pre_close(self, view: sublime.View) -> None:
|
||||
@@ -12,13 +17,34 @@ class VdiffEventListener(sublime_plugin.EventListener):
|
||||
state.drop(view)
|
||||
|
||||
def on_activated(self, view: sublime.View) -> None:
|
||||
"""Re-render when the tab comes back and the file or index changed meanwhile (agent edits)"""
|
||||
"""Re-render when the tab comes back and the file, the index or the branches changed meanwhile"""
|
||||
if state.is_review_view(view):
|
||||
refresh_if_changed(view, state.get(view) or restore_view(view))
|
||||
|
||||
def on_selection_modified(self, view: sublime.View) -> None:
|
||||
"""In the all-files view the header follows the caret from file to file"""
|
||||
if state.is_review_view(view):
|
||||
st = state.get(view)
|
||||
if st is not None:
|
||||
render.follow_caret(view, st)
|
||||
|
||||
def on_post_save(self, view: sublime.View) -> None:
|
||||
"""Review views showing the saved file re-render; the fingerprint decides which ones"""
|
||||
for view_id, st in state.tracked():
|
||||
review = sublime.View(view_id)
|
||||
if review.is_valid():
|
||||
refresh_if_changed(review, st)
|
||||
|
||||
def on_query_context(self, view: sublime.View, key: str, operator: int, operand: object, match_all: bool) -> Optional[bool]:
|
||||
"""Answer the keymap's `vdiff_mode` context: whether the review view shows "diff" or "branches"
|
||||
|
||||
Anything else is left to other packages (None)
|
||||
"""
|
||||
if key != MODE_CONTEXT or not state.is_review_view(view):
|
||||
return None
|
||||
mode = view.settings().get(state.MODE_SETTING) or state.MODE_DIFF
|
||||
if operator == sublime.OP_EQUAL:
|
||||
return mode == operand
|
||||
if operator == sublime.OP_NOT_EQUAL:
|
||||
return mode != operand
|
||||
return None
|
||||
|
||||
113
vdiff/palette.py
113
vdiff/palette.py
@@ -42,6 +42,21 @@ FILE_STATUS_FOREGROUND = "#ffffff"
|
||||
# sublime's former markup.deleted / markup.inserted colours
|
||||
FILE_DEL_FOREGROUND = "#d64646"
|
||||
FILE_INS_FOREGROUND = "#46d646"
|
||||
# red / green text on the plain editor background (the branches view's -/+ counts and tags): a region
|
||||
# only recolours its text when it is filled, so these carry the nudged editor background like SCOPE_CTX
|
||||
SCOPE_TEXT_DEL = "vdiff.text.del"
|
||||
SCOPE_TEXT_INS = "vdiff.text.ins"
|
||||
# the commit under the caret in the branches view: the scheme's own line-highlight colour, on its cells only,
|
||||
# and the red / green text of its counts and tags on that colour
|
||||
SCOPE_CURSOR = "vdiff.commit.cursor"
|
||||
SCOPE_CURSOR_DEL = "vdiff.commit.cursor.del"
|
||||
SCOPE_CURSOR_INS = "vdiff.commit.cursor.ins"
|
||||
# blend towards the foreground when the scheme names no line highlight
|
||||
CURSOR_BLEND = 0.12
|
||||
# the rules written whatever the settings say, by the view that needs them, so the restart hint names what is pending
|
||||
DIFF_SCOPES: Tuple[str, ...] = (SCOPE_FILE_HEADER, SCOPE_FILE_STATUS, SCOPE_FILE_DEL_COUNT, SCOPE_FILE_INS_COUNT)
|
||||
BRANCH_SCOPES: Tuple[str, ...] = (SCOPE_FILE_HEADER, SCOPE_FILE_DEL_COUNT, SCOPE_FILE_INS_COUNT, SCOPE_TEXT_DEL, SCOPE_TEXT_INS,
|
||||
SCOPE_CURSOR, SCOPE_CURSOR_DEL, SCOPE_CURSOR_INS)
|
||||
|
||||
# colours the user may set; an empty line colour keeps the colour scheme's tint or the plain-text look
|
||||
COLOUR_SETTINGS: Tuple[str, ...] = ("deleted_line_background", "inserted_line_background",
|
||||
@@ -96,8 +111,8 @@ PALETTE_PROBES: Tuple[str, ...] = (
|
||||
_palettes: Dict[str, Dict[str, int]] = {}
|
||||
# the override name the last ensure() resolved, so scope_for knows which palette to read
|
||||
_active: Optional[str] = None
|
||||
# schemes the user has already been told need a restart
|
||||
_notified: Set[Optional[str]] = set()
|
||||
# (scheme, scopes) settled for this session: the user was told they need a restart, or they were found live
|
||||
_notified: Set[Tuple[Optional[str], Tuple[str, ...]]] = set()
|
||||
# {override file name: the user colours it was provisioned with}, so changing one re-provisions
|
||||
_provisioned_with: Dict[str, Dict[str, str]] = {}
|
||||
|
||||
@@ -111,15 +126,19 @@ def reset() -> None:
|
||||
_active = None
|
||||
|
||||
|
||||
def claim_restart_notice(view: sublime.View) -> bool:
|
||||
"""Whether to tell the user to restart; True at most once per scheme
|
||||
def claim_restart_notice(view: sublime.View, scopes: Tuple[str, ...], tokens: bool = True) -> bool:
|
||||
"""Whether to tell the user to restart for `scopes` (and the token layer, with `tokens`); True at most once per scheme and set
|
||||
|
||||
Only when the override is written but not yet loaded
|
||||
Only when the override is written but the rules a view needs are not loaded yet; a view that needs
|
||||
only rules already live after an upgrade is not sent to restart for the others. Either answer is
|
||||
settled until the override is written again, so a render does not probe the scheme each time
|
||||
"""
|
||||
if not (_active and _palettes.get(_active)) or tokens_resolved(view, KINDS) or _active in _notified:
|
||||
key = (_active, scopes)
|
||||
if not (_active and _palettes.get(_active)) or key in _notified:
|
||||
return False
|
||||
_notified.add(_active)
|
||||
return True
|
||||
_notified.add(key)
|
||||
live = (not tokens or tokens_resolved(view, KINDS)) and all(scope_background(view, scope) for scope in scopes)
|
||||
return not live
|
||||
|
||||
|
||||
def scope_background(view: sublime.View, scope: str) -> Optional[str]:
|
||||
@@ -190,6 +209,35 @@ def line_scope(view: sublime.View, kind: str) -> str:
|
||||
return own if settings().get(setting) and scope_background(view, own) else scheme
|
||||
|
||||
|
||||
def text_scope(view: sublime.View, kind: str) -> str:
|
||||
"""Scope painting text red ("del") or green ("ins") on the editor background, once its rule is live
|
||||
|
||||
Until the restart that loads it, the scheme's diff tint stands in: a coloured background rather than plain text
|
||||
"""
|
||||
own, scheme = (SCOPE_TEXT_DEL, SCOPE_DEL) if kind == "del" else (SCOPE_TEXT_INS, SCOPE_INS)
|
||||
return own if scope_background(view, own) else scheme
|
||||
|
||||
|
||||
def count_scope(view: sublime.View, kind: str) -> str:
|
||||
"""Scope painting text red ("del") or green ("ins") on the file-heading background, once both rules are live
|
||||
|
||||
Before that, text_scope's stand-in: the heading tint is then a scheme fallback with no matching text rule anyway
|
||||
"""
|
||||
own = SCOPE_FILE_DEL_COUNT if kind == "del" else SCOPE_FILE_INS_COUNT
|
||||
return own if scope_background(view, SCOPE_FILE_HEADER) and scope_background(view, own) else text_scope(view, kind)
|
||||
|
||||
|
||||
def cursor_scope(view: sublime.View) -> Optional[str]:
|
||||
"""Scope tinting the commit under the caret like a highlighted line, or None until its rule is live"""
|
||||
return SCOPE_CURSOR if scope_background(view, SCOPE_CURSOR) else None
|
||||
|
||||
|
||||
def cursor_text_scope(view: sublime.View, kind: str) -> str:
|
||||
"""Scope painting text red ("del") or green ("ins") on the cursor's background, once live, else text_scope's stand-in"""
|
||||
own = SCOPE_CURSOR_DEL if kind == "del" else SCOPE_CURSOR_INS
|
||||
return own if scope_background(view, own) else text_scope(view, kind)
|
||||
|
||||
|
||||
def line_numbers_scope(view: sublime.View) -> str:
|
||||
"""Scope for the all-files line-number column: the user's colours once their rule is live, else plain text"""
|
||||
if (settings().get("line_numbers_foreground") or settings().get("line_numbers_background")) \
|
||||
@@ -233,6 +281,8 @@ def ensure(view: sublime.View) -> None:
|
||||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||||
with open(path, "w", encoding="utf-8") as f:
|
||||
json.dump(scheme, f, indent=4)
|
||||
# new rules: whether they are live is an open question again
|
||||
_notified.difference_update({key for key in _notified if key[0] == name})
|
||||
LOG.info("provisioned %d colours into colour scheme override %s", len(colours), path)
|
||||
except Exception:
|
||||
LOG.warning("could not write colour scheme override %s", path, exc_info=True)
|
||||
@@ -271,14 +321,31 @@ def _tints(view: sublime.View, user: Dict[str, str]) -> Dict[str, str]:
|
||||
return tints
|
||||
|
||||
|
||||
def _global_background(view: sublime.View) -> str:
|
||||
"""The scheme's editor background; style_for_scope reports none for scopes that do not set one"""
|
||||
def _global(view: sublime.View, key: str) -> Optional[str]:
|
||||
"""One of the scheme's global colours (background, line_highlight, ...), None when unset or unreadable"""
|
||||
try:
|
||||
background = view.style().get("background")
|
||||
return view.style().get(key)
|
||||
except Exception:
|
||||
LOG.debug("view.style failed", exc_info=True)
|
||||
background = None
|
||||
return background or "#000000"
|
||||
return None
|
||||
|
||||
|
||||
def _global_background(view: sublime.View) -> str:
|
||||
"""The scheme's editor background; style_for_scope reports none for scopes that do not set one"""
|
||||
return _global(view, "background") or "#000000"
|
||||
|
||||
|
||||
def _line_highlight(view: sublime.View) -> str:
|
||||
"""The scheme's line-highlight colour, else the editor background blended a little towards the foreground"""
|
||||
return _global(view, "line_highlight") or _blend(_global_background(view), foreground(view, "text.plain") or "#ffffff", CURSOR_BLEND)
|
||||
|
||||
|
||||
def _blend(colour: str, towards: str, fraction: float) -> str:
|
||||
"""#rrggbb moved `fraction` of the way towards `towards`; a colour in another form is returned as it is"""
|
||||
if not (colour.startswith("#") and len(colour) >= 7 and towards.startswith("#") and len(towards) >= 7):
|
||||
return colour
|
||||
mixed = (round(int(colour[i:i + 2], 16) * (1 - fraction) + int(towards[i:i + 2], 16) * fraction) for i in (1, 3, 5))
|
||||
return "#" + "".join(f"{min(255, max(0, c)):02x}" for c in mixed)
|
||||
|
||||
|
||||
def _nudge(colour: str) -> str:
|
||||
@@ -310,13 +377,21 @@ def _merge_rules(rules: List[Dict[str, str]], tints: Dict[str, str], colours: Di
|
||||
the line's colours; plain tints are added only when missing and never overwritten, so a hand-tuned one survives
|
||||
"""
|
||||
present = {rule.get("scope"): rule for rule in rules}
|
||||
# the all-files file heading and its deletion and insertion counts
|
||||
# the all-files file heading, the commit cursor of the branches view in the line-highlight colour (with the
|
||||
# foreground, so the text keeps its colour), then bold coloured text on the heading, on the editor background
|
||||
# (the branches view's counts and tags) and on the cursor, all in the heading counts' red and green
|
||||
header = user["file_header_background"] or FILE_HEADER_BACKGROUND
|
||||
wanted = [{"scope": SCOPE_FILE_HEADER, "background": header}]
|
||||
for scope, colour in ((SCOPE_FILE_STATUS, user["file_header_status_foreground"] or FILE_STATUS_FOREGROUND),
|
||||
(SCOPE_FILE_DEL_COUNT, user["file_header_deleted_foreground"] or FILE_DEL_FOREGROUND),
|
||||
(SCOPE_FILE_INS_COUNT, user["file_header_inserted_foreground"] or FILE_INS_FOREGROUND)):
|
||||
wanted.append({"scope": scope, "background": header, "foreground": colour, "font_style": "bold"})
|
||||
plain = _nudge(_global_background(view))
|
||||
highlight = _line_highlight(view)
|
||||
red = user["file_header_deleted_foreground"] or FILE_DEL_FOREGROUND
|
||||
green = user["file_header_inserted_foreground"] or FILE_INS_FOREGROUND
|
||||
wanted = [{"scope": SCOPE_FILE_HEADER, "background": header},
|
||||
{"scope": SCOPE_CURSOR, "background": highlight, "foreground": foreground(view, "text.plain") or "#ffffff"}]
|
||||
for scope, background, colour in ((SCOPE_FILE_STATUS, header, user["file_header_status_foreground"] or FILE_STATUS_FOREGROUND),
|
||||
(SCOPE_FILE_DEL_COUNT, header, red), (SCOPE_FILE_INS_COUNT, header, green),
|
||||
(SCOPE_TEXT_DEL, plain, red), (SCOPE_TEXT_INS, plain, green),
|
||||
(SCOPE_CURSOR_DEL, highlight, red), (SCOPE_CURSOR_INS, highlight, green)):
|
||||
wanted.append({"scope": scope, "background": background, "foreground": colour, "font_style": "bold"})
|
||||
# the user's line colours; an unset one keeps any old rule, which render then ignores
|
||||
for scope, setting in ((SCOPE_LINE_DEL, "deleted_line_background"), (SCOPE_LINE_INS, "inserted_line_background")):
|
||||
if user[setting]:
|
||||
|
||||
237
vdiff/render.py
237
vdiff/render.py
@@ -3,7 +3,7 @@ import bisect
|
||||
import html
|
||||
import logging
|
||||
import os
|
||||
from typing import Dict, List, NamedTuple, Optional, Sequence, Tuple, Union
|
||||
from typing import Any, Callable, Dict, List, NamedTuple, Optional, Sequence, Tuple, Union
|
||||
|
||||
import sublime
|
||||
import sublime_plugin
|
||||
@@ -11,7 +11,7 @@ import sublime_plugin
|
||||
from . import git, palette, parse
|
||||
from .git import FileChange, STATUS_NAMES
|
||||
from .parse import Block, Line
|
||||
from .state import VIEW_FLAG, ViewState
|
||||
from .state import MODE_BRANCHES, MODE_DIFF, MODE_SETTING, VIEW_FLAG, ViewState
|
||||
from .utils import file_count, settings, status
|
||||
|
||||
LOG = logging.getLogger("vdiff")
|
||||
@@ -27,6 +27,16 @@ KEY_FILE_DEL_COUNT = palette.SCOPE_FILE_DEL_COUNT
|
||||
KEY_FILE_INS_COUNT = palette.SCOPE_FILE_INS_COUNT
|
||||
KEY_FILE_STATUS = palette.SCOPE_FILE_STATUS
|
||||
KEY_FILE_PREFIX = "vdiff.file.prefix"
|
||||
KEY_BRANCH_SEL = "vdiff.branch.sel"
|
||||
KEY_BRANCH_DEL = "vdiff.branch.del"
|
||||
KEY_BRANCH_INS = "vdiff.branch.ins"
|
||||
KEY_BRANCH_STANDING_DEL = "vdiff.branch.standing.del"
|
||||
KEY_BRANCH_STANDING_INS = "vdiff.branch.standing.ins"
|
||||
KEY_BRANCH_SEL_DEL = "vdiff.branch.sel.del"
|
||||
KEY_BRANCH_SEL_INS = "vdiff.branch.sel.ins"
|
||||
KEY_BRANCH_CURSOR = "vdiff.branch.cursor"
|
||||
KEY_BRANCH_CURSOR_DEL = "vdiff.branch.cursor.del"
|
||||
KEY_BRANCH_CURSOR_INS = "vdiff.branch.cursor.ins"
|
||||
REGION_KEYS = (
|
||||
KEY_DEL,
|
||||
KEY_INS,
|
||||
@@ -39,6 +49,16 @@ REGION_KEYS = (
|
||||
KEY_FILE_INS_COUNT,
|
||||
KEY_FILE_STATUS,
|
||||
KEY_FILE_PREFIX,
|
||||
KEY_BRANCH_SEL,
|
||||
KEY_BRANCH_DEL,
|
||||
KEY_BRANCH_INS,
|
||||
KEY_BRANCH_STANDING_DEL,
|
||||
KEY_BRANCH_STANDING_INS,
|
||||
KEY_BRANCH_SEL_DEL,
|
||||
KEY_BRANCH_SEL_INS,
|
||||
KEY_BRANCH_CURSOR,
|
||||
KEY_BRANCH_CURSOR_DEL,
|
||||
KEY_BRANCH_CURSOR_INS,
|
||||
)
|
||||
|
||||
PHANTOM_KEY = "vdiff.header"
|
||||
@@ -65,6 +85,7 @@ SCOPE_FILE_HEADER = palette.SCOPE_FILE_HEADER
|
||||
|
||||
# sublime loads a newly created scheme override only after a restart
|
||||
NEEDS_RESTART = "restart Sublime Text to finish enabling syntax highlighting on changed lines"
|
||||
NEEDS_RESTART_BRANCHES = "restart Sublime Text to finish enabling the colours of the branches view"
|
||||
|
||||
|
||||
# actions: the ACTIONS names the row runs, a link when there is one; short: status-bar label, "" omits it
|
||||
@@ -104,10 +125,11 @@ KEY_GROUPS: List[Tuple[str, bool, List[Key]]] = [
|
||||
"View",
|
||||
True,
|
||||
[
|
||||
Key("r", "refresh", "refresh", ("refresh",)),
|
||||
Key("f", "changed files", "files", ("files",)),
|
||||
Key("c", "recent commits", "commits", ("commits",)),
|
||||
Key("b", "branches", "branches", ("branches",)),
|
||||
Key("v", "toggle all-files view", "view", ("view",)),
|
||||
Key("r", "refresh", "refresh", ("refresh",)),
|
||||
Key("left right", "collapse / expand file", "fold", ("collapse", "expand")),
|
||||
Key("z", "collapse / expand all files", "", ("fold_all",)),
|
||||
Key("esc", "close the view", "", ("close",)),
|
||||
@@ -115,12 +137,59 @@ KEY_GROUPS: List[Tuple[str, bool, List[Key]]] = [
|
||||
),
|
||||
]
|
||||
|
||||
KEYS: List[Key] = [key for _, _, group in KEY_GROUPS for key in group]
|
||||
# the keys of the branches view; the "applies in a commit" flag has no meaning there
|
||||
BRANCH_KEY_GROUPS: List[Tuple[str, bool, List[Key]]] = [
|
||||
(
|
||||
"Navigate",
|
||||
True,
|
||||
[
|
||||
Key("J K", "next / previous branch", "branch", ("next_branch", "prev_branch")),
|
||||
Key("j k", "next / previous commit", "commit", ("next_commit", "prev_commit")),
|
||||
Key("o v", "review the commit, or the changed files", "review", ("open_commit",)),
|
||||
],
|
||||
),
|
||||
(
|
||||
"Actions",
|
||||
True,
|
||||
[
|
||||
Key("⏎", "checkout remote branch", "checkout", ("checkout",)),
|
||||
Key("shift+⏎", "checkout a remote branch detached", "", ("checkout_detached",)),
|
||||
Key("L", "pull", "pull", ("pull",)),
|
||||
Key("P", "push, setting the upstream when missing", "push", ("push",)),
|
||||
Key("F", "fetch all remotes and prune", "fetch", ("fetch",)),
|
||||
Key("d", "delete the local branch", "delete", ("delete_branch",)),
|
||||
],
|
||||
),
|
||||
(
|
||||
"View",
|
||||
True,
|
||||
[
|
||||
Key("f", "changed files", "files", ("files",)),
|
||||
Key("c", "recent commits", "commits", ("commits",)),
|
||||
Key("b", "reload the branches", "", ("branches",)),
|
||||
Key("r", "refresh", "refresh", ("refresh",)),
|
||||
Key("esc", "close the view", "", ("close",)),
|
||||
],
|
||||
),
|
||||
]
|
||||
|
||||
KEY_HINTS = " ".join(f"{k.keys} {k.short}" for k in KEYS if k.short)
|
||||
MODE_KEY_GROUPS: Dict[str, List[Tuple[str, bool, List[Key]]]] = {MODE_DIFF: KEY_GROUPS, MODE_BRANCHES: BRANCH_KEY_GROUPS}
|
||||
|
||||
|
||||
def keys(mode: str = MODE_DIFF) -> List[Key]:
|
||||
"""Every key row of a mode's table"""
|
||||
return [key for _, _, group in MODE_KEY_GROUPS[mode] for key in group]
|
||||
|
||||
|
||||
def key_hints(mode: str = MODE_DIFF) -> str:
|
||||
"""The status-bar line of a mode: its keys with a short label"""
|
||||
return " ".join(f"{k.keys} {k.short}" for k in keys(mode) if k.short)
|
||||
|
||||
|
||||
def _key_width(mode: str) -> int:
|
||||
"""The popup font is the editor's, so the key column is padded to a fixed width in characters"""
|
||||
return max(len(k.keys) for k in keys(mode))
|
||||
|
||||
# the popup font is the editor's, so the key column is padded to a fixed width in characters
|
||||
_KEY_WIDTH = max(len(k.keys) for k in KEYS)
|
||||
|
||||
HEADER_CSS = """
|
||||
body { margin: 0; padding: 0.5rem 0.8rem; background-color: color(var(--background) blend(var(--foreground) 93%)); }
|
||||
@@ -170,11 +239,12 @@ def _clear_external_diagnostics(view: sublime.View) -> None:
|
||||
view.erase_regions(key + suffix)
|
||||
|
||||
|
||||
def init_view(view: sublime.View) -> None:
|
||||
def init_view(view: sublime.View, mode: str = MODE_DIFF) -> None:
|
||||
"""Settings a review view needs, applied once when it is created or restored"""
|
||||
s = view.settings()
|
||||
# mark the view as vdiff's and turn off editor chrome that does not fit a diff
|
||||
# mark the view as vdiff's, say which keys apply, and turn off editor chrome that does not fit a diff
|
||||
s.set(VIEW_FLAG, True)
|
||||
s.set(MODE_SETTING, mode)
|
||||
# native line numbers would be wrong: deleted lines have none
|
||||
s.set("line_numbers", False)
|
||||
s.set("word_wrap", False)
|
||||
@@ -202,7 +272,7 @@ def init_view(view: sublime.View) -> None:
|
||||
view.set_read_only(True)
|
||||
if not view.name():
|
||||
view.set_name("vDiff")
|
||||
view.set_status(STATUS_KEY, KEY_HINTS)
|
||||
view.set_status(STATUS_KEY, key_hints(mode))
|
||||
|
||||
|
||||
def index_point(view: sublime.View, index: int, col: int = 0) -> int:
|
||||
@@ -217,21 +287,18 @@ def caret_index(view: sublime.View) -> int:
|
||||
return view.rowcol(view.sel()[0].begin())[0] - _HEADER_ROWS
|
||||
|
||||
|
||||
def fingerprint(st: ViewState) -> Optional[Tuple[Optional[float], ...]]:
|
||||
"""Cheap "did anything change" key for working-tree mode: mtimes of the shown files and of the git index"""
|
||||
def fingerprint(st: ViewState) -> Optional[Tuple[Any, ...]]:
|
||||
"""Cheap "did anything change" key of a working-tree diff: mtimes of the shown files and of the git index;
|
||||
None for a commit or nothing shown (the branches view keeps its own, see branches.fingerprint)"""
|
||||
if st.in_commit or st.change is None:
|
||||
return None
|
||||
files = st.files if st.all_mode else [st.change]
|
||||
index = git.index_path(st.repo)
|
||||
return tuple(_mtime(os.path.join(st.repo, c.path)) for c in files) + (_mtime(index) if index else None,)
|
||||
return worktree_fingerprint(st.repo, st.files if st.all_mode else [st.change])
|
||||
|
||||
|
||||
def _mtime(path: str) -> Optional[float]:
|
||||
"""Modification time of `path`, or None when it cannot be stat'ed"""
|
||||
try:
|
||||
return os.stat(path).st_mtime
|
||||
except OSError:
|
||||
return None
|
||||
def worktree_fingerprint(repo: str, files: Sequence[FileChange]) -> Tuple[Optional[float], ...]:
|
||||
"""mtimes of `files` and of the index they are staged in"""
|
||||
index = git.index_path(repo)
|
||||
return tuple(git.mtime(os.path.join(repo, c.path)) for c in files) + (git.mtime(index) if index else None,)
|
||||
|
||||
|
||||
def flash(view: sublime.View) -> None:
|
||||
@@ -268,7 +335,7 @@ def render_message(view: sublime.View, st: ViewState, message: str) -> None:
|
||||
st.binary = False
|
||||
_replace(view, message)
|
||||
view.assign_syntax("scope:text.plain")
|
||||
_finish(view, st, 0, 0, "vDiff")
|
||||
_finish(view, st, MODE_DIFF, "vDiff", header_html(st, 0, 0))
|
||||
|
||||
|
||||
def _trim_context(lines: Sequence[Line], context: int) -> List[Line]:
|
||||
@@ -348,16 +415,18 @@ def render_all(view: sublime.View, st: ViewState, focus: Union[None, str, Tuple[
|
||||
# paint its colours as regions
|
||||
view.assign_syntax("scope:text.plain")
|
||||
palette.ensure(view)
|
||||
if palette.claim_restart_notice(view):
|
||||
if palette.claim_restart_notice(view, palette.DIFF_SCOPES):
|
||||
status(NEEDS_RESTART)
|
||||
_all_colours(view, st, [c.path for c in st.files if c.path not in st.collapsed])
|
||||
# the token colours only once their scheme rules are live; tokenising before the restart would be thrown away
|
||||
resolved = palette.tokens_resolved(view)
|
||||
if resolved:
|
||||
_all_colours(view, st, [c.path for c in st.files if c.path not in st.collapsed])
|
||||
# per-row regions: heading counts, number prefix, tint, token colours
|
||||
starts = _row_starts_for_text(rows)
|
||||
del_regions, ins_regions, file_regions, prefix_regions = [], [], [], []
|
||||
file_del_counts, file_ins_counts, file_statuses = [], [], []
|
||||
token_groups: Dict[str, List[sublime.Region]] = {}
|
||||
default_colour = palette.foreground(view, "text.plain")
|
||||
resolved = palette.tokens_resolved(view)
|
||||
# context colours come from a later scheme rule, so they may still await a restart
|
||||
ctx_resolved = palette.tokens_resolved(view, ("ctx",))
|
||||
for i, (change, line, section) in enumerate(metadata):
|
||||
@@ -403,8 +472,7 @@ def render_all(view: sublime.View, st: ViewState, focus: Union[None, str, Tuple[
|
||||
view.add_regions(KEY_FILE_PREFIX, prefix_regions, palette.line_numbers_scope(view), flags=sublime.DRAW_NO_OUTLINE)
|
||||
for scope, regions in token_groups.items():
|
||||
view.add_regions(palette.token_key(scope), regions, scope, flags=sublime.DRAW_NO_OUTLINE)
|
||||
insertions, deletions = _totals(st.files)
|
||||
_finish(view, st, insertions, deletions, "⟐ all files")
|
||||
_finish(view, st, MODE_DIFF, "⟐ all files", _all_header_html(st))
|
||||
# place the caret: on the focused change's first row, else on `heading` (a file's or the top)
|
||||
if isinstance(focus, tuple):
|
||||
heading = next((row for row, shown in zip(st.all_change_rows, st.all_change_row_targets) if shown == focus), 0)
|
||||
@@ -482,6 +550,35 @@ def all_change_at(view: sublime.View, st: ViewState) -> Optional[FileChange]:
|
||||
return None
|
||||
|
||||
|
||||
def all_change_below(view: sublime.View, st: ViewState) -> Optional[FileChange]:
|
||||
"""File of the first heading or diff row at or below the caret: the file a blank row or the top row precedes"""
|
||||
for change, _, _ in st.all_rows[max(0, caret_index(view)):]:
|
||||
if change is not None:
|
||||
return change
|
||||
return None
|
||||
|
||||
|
||||
def follow_caret(view: sublime.View, st: ViewState) -> None:
|
||||
"""In the all-files view, make the file under the caret current and redraw the header for it
|
||||
|
||||
Only when the caret crossed into another file, and not while a render is pending: the rows then
|
||||
describe the old text
|
||||
"""
|
||||
if st.in_branches or not st.all_mode or st.rendered_token != st.token:
|
||||
return
|
||||
change = all_change_at(view, st)
|
||||
if change is None or (st.change is not None and change.path == st.change.path):
|
||||
return
|
||||
st.change = change
|
||||
_header(view, st, _all_header_html(st))
|
||||
|
||||
|
||||
def _all_header_html(st: ViewState) -> str:
|
||||
"""The all-files header: the totals on the summary line, the current file's own counts in the title"""
|
||||
change = st.change
|
||||
return header_html(st, change.insertions if change else 0, change.deletions if change else 0)
|
||||
|
||||
|
||||
def render(view: sublime.View, st: ViewState) -> None:
|
||||
"""Draw st.lines for st.change into the view"""
|
||||
change = st.change
|
||||
@@ -505,12 +602,12 @@ def render(view: sublime.View, st: ViewState) -> None:
|
||||
# here rather than init_view: during a session restore the scheme colours still read as absent
|
||||
palette.ensure(view)
|
||||
_paint_regions(view, st)
|
||||
if palette.claim_restart_notice(view):
|
||||
if palette.claim_restart_notice(view, palette.DIFF_SCOPES):
|
||||
status(NEEDS_RESTART)
|
||||
|
||||
# header and bookkeeping, then the caret and scroll back to the top
|
||||
ins, dele = parse.counts(lines)
|
||||
_finish(view, st, ins, dele, f"⟐ {os.path.basename(change.path)}")
|
||||
_finish(view, st, MODE_DIFF, f"⟐ {os.path.basename(change.path)}", header_html(st, ins, dele))
|
||||
view.sel().clear()
|
||||
view.sel().add(sublime.Region(index_point(view, 0)))
|
||||
view.set_viewport_position((0, 0), False)
|
||||
@@ -628,13 +725,21 @@ def _colour_runs(
|
||||
return runs
|
||||
|
||||
|
||||
def _finish(view: sublime.View, st: ViewState, ins: int, dele: int, name: str) -> None:
|
||||
"""Header, tab name, status bar and bookkeeping shared by every render"""
|
||||
_header(view, st, ins, dele)
|
||||
def _finish(view: sublime.View, st: ViewState, mode: str, name: str, header: str, key: Callable[[ViewState], Any] = fingerprint) -> None:
|
||||
"""Mode, header, tab name, status bar and bookkeeping shared by every render: what was drawn is settled here
|
||||
|
||||
`key` is the mode's fingerprint, the branches view's own one there
|
||||
"""
|
||||
st.mode = mode
|
||||
_header(view, st, header)
|
||||
view.set_name(name)
|
||||
view.set_status(STATUS_KEY, KEY_HINTS)
|
||||
view.set_status(STATUS_KEY, key_hints(st.mode))
|
||||
view.settings().set(MODE_SETTING, st.mode)
|
||||
# the caret row's highlight; the branches view turns it off itself once it tints the caret's commit
|
||||
view.settings().set("highlight_line", True)
|
||||
st.persist(view)
|
||||
st.fingerprint = fingerprint(st)
|
||||
st.fingerprint = key(st)
|
||||
st.drawn = st.describe()
|
||||
|
||||
|
||||
def _replace(view: sublime.View, text: str) -> None:
|
||||
@@ -696,11 +801,6 @@ def _char_regions(
|
||||
return deleted, inserted
|
||||
|
||||
|
||||
def _totals(files: Sequence[FileChange]) -> Tuple[int, int]:
|
||||
"""Summed numstat counts; binary files carry None counts and add nothing"""
|
||||
return sum(c.insertions or 0 for c in files), sum(c.deletions or 0 for c in files)
|
||||
|
||||
|
||||
def _summary_html(st: ViewState) -> str:
|
||||
"""Summary line above the title: the commit on one line, or the staged/unstaged split and totals"""
|
||||
if not st.files and not st.commit:
|
||||
@@ -708,12 +808,11 @@ def _summary_html(st: ViewState) -> str:
|
||||
if st.in_commit:
|
||||
text = " · ".join(_commit_parts(st))
|
||||
else:
|
||||
# staged means "has something staged": a partially staged file counts as staged only
|
||||
staged = sum(1 for c in st.files if c.staged)
|
||||
insertions, deletions = _totals(st.files)
|
||||
# the same counts as the branches view's working-tree entry: a partially staged file is on both sides
|
||||
stat = git.worktree_stats(st.files)
|
||||
text = (
|
||||
f"{staged} staged, {len(st.files) - staged} unstaged"
|
||||
f' · <span class="del">-{deletions}</span> <span class="ins">+{insertions}</span>'
|
||||
f"{stat.staged} staged, {stat.unstaged} unstaged"
|
||||
f' · <span class="del">-{stat.deletions}</span> <span class="ins">+{stat.insertions}</span>'
|
||||
)
|
||||
return f'<div class="summary">{text}</div>'
|
||||
|
||||
@@ -728,8 +827,10 @@ def _commit_parts(st: ViewState) -> List[str]:
|
||||
parts.append(html.escape(info.author))
|
||||
parts.append(f'<span class="when">{html.escape(info.date)}</span>')
|
||||
# binary files add nothing to the line totals but still count toward the file total
|
||||
insertions, deletions = _totals(st.files)
|
||||
parts.append(f"{file_count(len(st.files))} changed" f' <span class="del">-{deletions}</span> <span class="ins">+{insertions}</span>')
|
||||
stat = git.worktree_stats(st.files)
|
||||
parts.append(
|
||||
f"{file_count(stat.files)} changed" f' <span class="del">-{stat.deletions}</span> <span class="ins">+{stat.insertions}</span>'
|
||||
)
|
||||
# the subject, plus the body's first line
|
||||
if info:
|
||||
message = html.escape(info.subject)
|
||||
@@ -740,8 +841,8 @@ def _commit_parts(st: ViewState) -> List[str]:
|
||||
return parts
|
||||
|
||||
|
||||
def header_html(st: ViewState, ins: int, dele: int) -> str:
|
||||
"""The minihtml header: the summary line, then the shown file's path, counts, state and action links"""
|
||||
def header_html(st: ViewState, ins: Optional[int], dele: Optional[int]) -> str:
|
||||
"""The minihtml header: the summary line, then the shown file's path, its counts (None for a binary file), state and action links"""
|
||||
change = st.change
|
||||
# the title: path, rename source, counts and working-tree state
|
||||
if change is None:
|
||||
@@ -750,7 +851,10 @@ def header_html(st: ViewState, ins: int, dele: int) -> str:
|
||||
title = f'<span class="path">{html.escape(change.path)}</span>'
|
||||
if change.old_path:
|
||||
title += f' <span class="old">← {html.escape(change.old_path)}</span>'
|
||||
title += f' <span class="del">-{dele}</span> <span class="ins">+{ins}</span>'
|
||||
if ins is None or dele is None:
|
||||
title += ' <span class="state">binary</span>'
|
||||
else:
|
||||
title += f' <span class="del">-{dele}</span> <span class="ins">+{ins}</span>'
|
||||
if not st.in_commit:
|
||||
state = "staged" if change.staged else STATUS_NAMES.get(change.status, "")
|
||||
if state:
|
||||
@@ -764,13 +868,20 @@ def header_html(st: ViewState, ins: int, dele: int) -> str:
|
||||
actions.append('<a href="discard" class="danger">Discard</a>')
|
||||
if change is not None:
|
||||
actions.append('<a href="open">Open</a>')
|
||||
actions.append('<a href="files">Files</a>')
|
||||
actions.append('<a href="commits">Commits</a>')
|
||||
actions.append('<a href="help" title="keys">?</a>')
|
||||
return header_frame(_summary_html(st), title, actions)
|
||||
|
||||
|
||||
def header_frame(summary: str, title: str, actions: Sequence[str]) -> str:
|
||||
"""The header's body: the summary line, then the title with `actions` and the links every view has"""
|
||||
links = list(actions) + [
|
||||
'<a href="files">Files</a>',
|
||||
'<a href="commits">Commits</a>',
|
||||
'<a href="branches">Branches</a>',
|
||||
'<a href="help" title="keys">?</a>',
|
||||
]
|
||||
return (
|
||||
f'<body id="vdiff-header"><style>{HEADER_CSS}</style>{_summary_html(st)}'
|
||||
f'<div>{title}<span class="actions">{"".join(actions)}</span></div></body>'
|
||||
f'<body id="vdiff-header"><style>{HEADER_CSS}</style>{summary}'
|
||||
f'<div>{title}<span class="actions">{"".join(links)}</span></div></body>'
|
||||
)
|
||||
|
||||
|
||||
@@ -779,25 +890,31 @@ def _run_action(view: sublime.View, href: str) -> None:
|
||||
view.run_command("vdiff_action", {"action": href})
|
||||
|
||||
|
||||
def _header(view: sublime.View, st: ViewState, ins: int, dele: int) -> None:
|
||||
"""One block phantom above the text; redrawn from scratch, so no PhantomSet state to keep"""
|
||||
def _header(view: sublime.View, st: ViewState, html_text: str) -> None:
|
||||
"""One block phantom above the text, redrawn from scratch unless the same one is still in place"""
|
||||
# keyed on the buffer too: replacing the text can drop the phantom while query_phantom still answers for it
|
||||
drawn = html_text, view.change_count()
|
||||
if st.header == drawn:
|
||||
return
|
||||
|
||||
def navigate(href: str) -> None:
|
||||
"""Run the clicked header link's action"""
|
||||
_run_action(view, href)
|
||||
|
||||
view.erase_phantoms(PHANTOM_KEY)
|
||||
view.add_phantom(PHANTOM_KEY, sublime.Region(0), header_html(st, ins, dele), sublime.LAYOUT_BLOCK, navigate)
|
||||
view.add_phantom(PHANTOM_KEY, sublime.Region(0), html_text, sublime.LAYOUT_BLOCK, navigate)
|
||||
st.header = drawn
|
||||
|
||||
|
||||
# --- key help popup ---------------------------------------------------------
|
||||
|
||||
|
||||
def help_html(st: ViewState) -> str:
|
||||
"""The minihtml key list; rows that need a working-tree file are dimmed while a commit is shown"""
|
||||
"""The minihtml key list of the shown mode; rows that need a working-tree file are dimmed while a commit is shown"""
|
||||
parts: List[str] = []
|
||||
width = _key_width(st.mode)
|
||||
# per group a heading, dimmed with a note when it does not apply in a commit
|
||||
for title, applies, group in KEY_GROUPS:
|
||||
for title, applies, group in MODE_KEY_GROUPS[st.mode]:
|
||||
dim = st.in_commit and not applies
|
||||
heading = html.escape(title)
|
||||
if dim:
|
||||
@@ -807,7 +924,7 @@ def help_html(st: ViewState) -> str:
|
||||
row_class = "dim" if dim else "row"
|
||||
# a row per key with a padded key column; a single-action row becomes a link
|
||||
for key in group:
|
||||
pad = " " * (_KEY_WIDTH - len(key.keys) + 2)
|
||||
pad = " " * (width - len(key.keys) + 2)
|
||||
row = f'<span class="k">{html.escape(key.keys)}</span>{pad}{html.escape(key.label)}'
|
||||
if len(key.actions) == 1 and not dim:
|
||||
row = f'<a href="{key.actions[0]}">{row}</a>'
|
||||
|
||||
@@ -6,11 +6,16 @@ if TYPE_CHECKING:
|
||||
# annotation-only, so this module keeps importing neither sublime nor the rest of the package
|
||||
import sublime
|
||||
|
||||
from .git import CommitInfo, FileChange
|
||||
from .branches import Paint
|
||||
from .git import Commit, CommitInfo, FileChange, Ref
|
||||
from .parse import Block, Line
|
||||
|
||||
# view setting marking a review view (keymap context "setting.vdiff_view")
|
||||
VIEW_FLAG = "vdiff_view"
|
||||
# view setting naming what the view shows, "diff" or "branches", so the keymap can bind a key per mode
|
||||
MODE_SETTING = "vdiff_mode"
|
||||
MODE_DIFF = "diff"
|
||||
MODE_BRANCHES = "branches"
|
||||
# view setting holding what the view shows, so a restored tab can re-render
|
||||
VIEW_DATA = "vdiff"
|
||||
|
||||
@@ -23,6 +28,17 @@ class Kept(NamedTuple):
|
||||
change: Optional["FileChange"]
|
||||
files: List["FileChange"]
|
||||
all_mode: bool
|
||||
mode: str = MODE_DIFF
|
||||
|
||||
|
||||
class BranchRow(NamedTuple):
|
||||
"""What one row of the branches view holds: the branch of its left cell, the index of its right-column
|
||||
item (0 the working tree, i + 1 the i-th commit, -1 none) and the coloured spans of its right cell
|
||||
as (start, end, "del" | "ins") offsets from the row's start"""
|
||||
|
||||
ref: Optional["Ref"]
|
||||
commit: int
|
||||
spans: Tuple[Tuple[int, int, str], ...] = ()
|
||||
|
||||
|
||||
def find_change(files: Sequence["FileChange"], path: Optional[str]) -> int:
|
||||
@@ -49,7 +65,8 @@ class ViewState:
|
||||
token: int = 0 # bumped per show request; a stale async result is dropped
|
||||
rendered_token: int = -1 # token of the request that produced the current render
|
||||
highlight: int = 0 # bumped per quick-panel highlight, to debounce previews
|
||||
fingerprint: Optional[Tuple[Optional[float], ...]] = None # all-files view: diffs cached so collapse/expand is instant
|
||||
fingerprint: Optional[Tuple[Any, ...]] = None # what the last render saw; see render.fingerprint
|
||||
drawn: Optional[Tuple[Any, ...]] = None # what the last render drew, as describe() put it
|
||||
all_mode: bool = False
|
||||
all_diffs: Dict[str, Tuple[List["Line"], List["Block"], bool]] = field(default_factory=dict)
|
||||
all_colours: Dict[str, Dict[Tuple[Optional[int], Optional[int]], List[Tuple[int, int, str]]]] = field(default_factory=dict)
|
||||
@@ -58,12 +75,43 @@ class ViewState:
|
||||
all_change_rows: List[int] = field(default_factory=list)
|
||||
all_change_targets: List[Tuple[str, int]] = field(default_factory=list)
|
||||
all_change_row_targets: List[Tuple[str, int]] = field(default_factory=list)
|
||||
# the branches view: what it lists, which branch is selected and what each row holds
|
||||
mode: str = MODE_DIFF
|
||||
branch_ref: Optional[str] = None # name of the selected branch, e.g. "main" or "origin/main"
|
||||
branch_head_sha: str = "" # HEAD's short hash, "" before the first commit
|
||||
branch_refs: List["Ref"] = field(default_factory=list)
|
||||
branch_remotes: List[str] = field(default_factory=list)
|
||||
branch_commits: List["Commit"] = field(default_factory=list)
|
||||
branch_changes: List["FileChange"] = field(default_factory=list) # the working tree, listed with the branches
|
||||
branch_rows: List[BranchRow] = field(default_factory=list)
|
||||
branch_width: int = 0 # the left column's width in the last render
|
||||
branch_paint: Optional["Paint"] = None # the last render's row geometry and scopes, see branches.Paint
|
||||
header: Optional[Tuple[str, int]] = None # the header phantom last drawn: its html and the buffer's change_count then
|
||||
|
||||
@property
|
||||
def in_commit(self) -> bool:
|
||||
"""Whether a commit is being reviewed rather than the working tree"""
|
||||
return self.sha is not None
|
||||
|
||||
def describe(self) -> Tuple[Any, ...]:
|
||||
"""What the state says is shown: the branches view, or a diff's commit, mode and file"""
|
||||
if self.in_branches:
|
||||
return (self.mode,)
|
||||
return self.mode, self.sha, self.all_mode, self.change.path if self.change else None
|
||||
|
||||
@property
|
||||
def in_branches(self) -> bool:
|
||||
"""Whether the branches view is shown rather than a diff"""
|
||||
return self.mode == MODE_BRANCHES
|
||||
|
||||
def selected_ref(self) -> Optional["Ref"]:
|
||||
"""The selected branch, or None when it is not listed (any more)"""
|
||||
return next((r for r in self.branch_refs if r.name == self.branch_ref), None)
|
||||
|
||||
def current_branch(self) -> Optional["Ref"]:
|
||||
"""The checked-out branch, None when detached or before the first commit"""
|
||||
return next((r for r in self.branch_refs if r.current), None)
|
||||
|
||||
def index(self) -> int:
|
||||
"""Position in `files` of the file being shown or loaded, or -1
|
||||
|
||||
@@ -75,7 +123,7 @@ class ViewState:
|
||||
|
||||
def kept(self) -> Kept:
|
||||
"""Snapshot of what to go back to on Esc"""
|
||||
return Kept(self.sha, self.commit, self.change, list(self.files), self.all_mode)
|
||||
return Kept(self.sha, self.commit, self.change, list(self.files), self.all_mode, self.mode)
|
||||
|
||||
def enter(self, sha: Optional[str] = None, commit: Optional["CommitInfo"] = None) -> Kept:
|
||||
"""Switch to browsing a commit (or the working tree); returns what to restore on Esc"""
|
||||
@@ -87,7 +135,7 @@ class ViewState:
|
||||
|
||||
def restore(self, kept: Kept) -> None:
|
||||
"""Go back to a snapshot; its file becomes the requested one"""
|
||||
self.sha, self.commit, self.change, self.files, self.all_mode = kept
|
||||
self.sha, self.commit, self.change, self.files, self.all_mode, self.mode = kept
|
||||
self.requested = kept.change
|
||||
|
||||
def set_all_diffs(self, diffs: Dict[str, Tuple[List["Line"], List["Block"], bool]]) -> None:
|
||||
@@ -102,6 +150,9 @@ class ViewState:
|
||||
def persist(self, view: "sublime.View") -> None:
|
||||
"""Mirror the essentials into view settings (survives a restart)"""
|
||||
data: Dict[str, Any] = {"repo": self.repo, "sha": self.sha}
|
||||
if self.in_branches:
|
||||
data["mode"] = MODE_BRANCHES
|
||||
data["ref"] = self.branch_ref
|
||||
if self.all_mode:
|
||||
data["all_mode"] = True
|
||||
if self.change:
|
||||
|
||||
@@ -8,6 +8,8 @@ from . import git
|
||||
|
||||
SETTINGS_FILE = "vDiff.sublime-settings"
|
||||
|
||||
DEBOUNCE_MS = 60
|
||||
|
||||
LOG = logging.getLogger("vdiff")
|
||||
|
||||
_settings: Optional[sublime.Settings] = None
|
||||
@@ -28,9 +30,15 @@ def apply_git_binary() -> None:
|
||||
git.GIT_BINARY = settings().get("git_binary") or "git"
|
||||
|
||||
|
||||
def file_count(count: int) -> str:
|
||||
"""'1 file' / '3 files' for a message"""
|
||||
return f'{count} {"file" if count == 1 else "files"}'
|
||||
def commits_count() -> int:
|
||||
"""How many commits the commits panel and the branches view list"""
|
||||
return int(settings().get("commits_count", 30) or 30)
|
||||
|
||||
|
||||
def file_count(count: int, qualifier: str = "") -> str:
|
||||
"""'1 file' / '3 files' for a message; a qualifier goes before the noun ('1 staged file')"""
|
||||
noun = "file" if count == 1 else "files"
|
||||
return f"{count} {qualifier} {noun}" if qualifier else f"{count} {noun}"
|
||||
|
||||
|
||||
def status(message: str) -> None:
|
||||
|
||||
Reference in New Issue
Block a user