This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11636

chistedit: move view state from a dict to a custom class
ClosedPublic

Authored by martinvonz on Oct 12 2021, 1:04 PM.

Details

Reviewers
durin42
pulkit
Group Reviewers
hg-reviewers
Commits
rHGb6fc7d188f68: chistedit: move view state from a dict to a custom class

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Oct 12 2021, 1:04 PM
pulkit accepted this revision.Oct 13 2021, 2:47 PM
This revision is now accepted and ready to land.Oct 13 2021, 2:47 PM

Revision Contents
Changeset List

PathPackages
Mhgext/histedit.py (117 lines)

Diff 30776

hgext/histedit.py

self.conflicts.remove(other) self.conflicts.remove(other)
return self.conflicts return self.conflicts
# ============ EVENTS =============== # ============ EVENTS ===============
def movecursor(state, oldpos, newpos): def movecursor(state, oldpos, newpos):
"""Change the rule/changeset that the cursor is pointing to, regardless of """Change the rule/changeset that the cursor is pointing to, regardless of
current mode (you can switch between patches from the view patch window).""" current mode (you can switch between patches from the view patch window)."""
state[b'pos'] = newpos state.pos = newpos
mode, _ = state[b'mode'] mode, _ = state.mode
if mode == MODE_RULES: if mode == MODE_RULES:
# Scroll through the list by updating the view for MODE_RULES, so that # Scroll through the list by updating the view for MODE_RULES, so that
# even if we are not currently viewing the rules, switching back will # even if we are not currently viewing the rules, switching back will
# result in the cursor's rule being visible. # result in the cursor's rule being visible.
modestate = state[b'modes'][MODE_RULES] modestate = state.modes[MODE_RULES]
if newpos < modestate[b'line_offset']: if newpos < modestate[b'line_offset']:
modestate[b'line_offset'] = newpos modestate[b'line_offset'] = newpos
elif newpos > modestate[b'line_offset'] + state[b'page_height'] - 1: elif newpos > modestate[b'line_offset'] + state.page_height - 1:
modestate[b'line_offset'] = newpos - state[b'page_height'] + 1 modestate[b'line_offset'] = newpos - state.page_height + 1
# Reset the patch view region to the top of the new patch. # Reset the patch view region to the top of the new patch.
state[b'modes'][MODE_PATCH][b'line_offset'] = 0 state.modes[MODE_PATCH][b'line_offset'] = 0
def changemode(state, mode): def changemode(state, mode):
curmode, _ = state[b'mode'] curmode, _ = state.mode
state[b'mode'] = (mode, curmode) state.mode = (mode, curmode)
if mode == MODE_PATCH: if mode == MODE_PATCH:
state[b'modes'][MODE_PATCH][b'patchcontents'] = patchcontents(state) state.modes[MODE_PATCH][b'patchcontents'] = patchcontents(state)
def makeselection(state, pos): def makeselection(state, pos):
state[b'selected'] = pos state.selected = pos
def swap(state, oldpos, newpos): def swap(state, oldpos, newpos):
"""Swap two positions and calculate necessary conflicts in """Swap two positions and calculate necessary conflicts in
O(|newpos-oldpos|) time""" O(|newpos-oldpos|) time"""
rules = state[b'rules'] rules = state.rules
assert 0 <= oldpos < len(rules) and 0 <= newpos < len(rules) assert 0 <= oldpos < len(rules) and 0 <= newpos < len(rules)
rules[oldpos], rules[newpos] = rules[newpos], rules[oldpos] rules[oldpos], rules[newpos] = rules[newpos], rules[oldpos]
# TODO: swap should not know about histeditrule's internals # TODO: swap should not know about histeditrule's internals
rules[newpos].pos = newpos rules[newpos].pos = newpos
rules[oldpos].pos = oldpos rules[oldpos].pos = oldpos
start = min(oldpos, newpos) start = min(oldpos, newpos)
end = max(oldpos, newpos) end = max(oldpos, newpos)
for r in pycompat.xrange(start, end + 1): for r in pycompat.xrange(start, end + 1):
rules[newpos].checkconflicts(rules[r]) rules[newpos].checkconflicts(rules[r])
rules[oldpos].checkconflicts(rules[r]) rules[oldpos].checkconflicts(rules[r])
if state[b'selected']: if state.selected:
makeselection(state, newpos) makeselection(state, newpos)
def changeaction(state, pos, action): def changeaction(state, pos, action):
"""Change the action state on the given position to the new action""" """Change the action state on the given position to the new action"""
rules = state[b'rules'] rules = state.rules
assert 0 <= pos < len(rules) assert 0 <= pos < len(rules)
rules[pos].action = action rules[pos].action = action
def cycleaction(state, pos, next=False): def cycleaction(state, pos, next=False):
"""Changes the action state the next or the previous action from """Changes the action state the next or the previous action from
the action list""" the action list"""
rules = state[b'rules'] rules = state.rules
assert 0 <= pos < len(rules) assert 0 <= pos < len(rules)
current = rules[pos].action current = rules[pos].action
assert current in KEY_LIST assert current in KEY_LIST
index = KEY_LIST.index(current) index = KEY_LIST.index(current)
if next: if next:
index += 1 index += 1
else: else:
index -= 1 index -= 1
changeaction(state, pos, KEY_LIST[index % len(KEY_LIST)]) changeaction(state, pos, KEY_LIST[index % len(KEY_LIST)])
def changeview(state, delta, unit): def changeview(state, delta, unit):
"""Change the region of whatever is being viewed (a patch or the list of """Change the region of whatever is being viewed (a patch or the list of
changesets). 'delta' is an amount (+/- 1) and 'unit' is 'page' or 'line'.""" changesets). 'delta' is an amount (+/- 1) and 'unit' is 'page' or 'line'."""
mode, _ = state[b'mode'] mode, _ = state.mode
if mode != MODE_PATCH: if mode != MODE_PATCH:
return return
mode_state = state[b'modes'][mode] mode_state = state.modes[mode]
num_lines = len(mode_state[b'patchcontents']) num_lines = len(mode_state[b'patchcontents'])
page_height = state[b'page_height'] page_height = state.page_height
unit = page_height if unit == b'page' else 1 unit = page_height if unit == b'page' else 1
num_pages = 1 + (num_lines - 1) // page_height num_pages = 1 + (num_lines - 1) // page_height
max_offset = (num_pages - 1) * page_height max_offset = (num_pages - 1) * page_height
newline = mode_state[b'line_offset'] + delta * unit newline = mode_state[b'line_offset'] + delta * unit
mode_state[b'line_offset'] = max(0, min(max_offset, newline)) mode_state[b'line_offset'] = max(0, min(max_offset, newline))
def event(state, ch): def event(state, ch):
"""Change state based on the current character input """Change state based on the current character input
This takes the current state and based on the current character input from This takes the current state and based on the current character input from
the user we change the state. the user we change the state.
""" """
selected = state[b'selected'] selected = state.selected
oldpos = state[b'pos'] oldpos = state.pos
rules = state[b'rules'] rules = state.rules
if ch in (curses.KEY_RESIZE, b"KEY_RESIZE"): if ch in (curses.KEY_RESIZE, b"KEY_RESIZE"):
return E_RESIZE return E_RESIZE
lookup_ch = ch lookup_ch = ch
if ch is not None and b'0' <= ch <= b'9': if ch is not None and b'0' <= ch <= b'9':
lookup_ch = b'0' lookup_ch = b'0'
curmode, prevmode = state[b'mode'] curmode, prevmode = state.mode
action = KEYTABLE[curmode].get( action = KEYTABLE[curmode].get(
lookup_ch, KEYTABLE[b'global'].get(lookup_ch) lookup_ch, KEYTABLE[b'global'].get(lookup_ch)
) )
if action is None: if action is None:
return return
if action in (b'down', b'move-down'): if action in (b'down', b'move-down'):
newpos = min(oldpos + 1, len(rules) - 1) newpos = min(oldpos + 1, len(rules) - 1)
movecursor(state, oldpos, newpos) movecursor(state, oldpos, newpos)
def _trunc_tail(line, n): def _trunc_tail(line, n):
if len(line) <= n: if len(line) <= n:
return line return line
return line[: n - 2] + b' >' return line[: n - 2] + b' >'
def patchcontents(state): def patchcontents(state):
repo = state[b'repo'] repo = state.repo
rule = state[b'rules'][state[b'pos']] rule = state.rules[state.pos]
displayer = logcmdutil.changesetdisplayer( displayer = logcmdutil.changesetdisplayer(
repo.ui, repo, {b"patch": True, b"template": b"status"}, buffered=True repo.ui, repo, {b"patch": True, b"template": b"status"}, buffered=True
) )
overrides = {(b'ui', b'verbose'): True} overrides = {(b'ui', b'verbose'): True}
with repo.ui.configoverride(overrides, source=b'histedit'): with repo.ui.configoverride(overrides, source=b'histedit'):
displayer.show(rule.ctx) displayer.show(rule.ctx)
displayer.close() displayer.close()
return displayer.hunk[rule.ctx.rev()].splitlines() return displayer.hunk[rule.ctx.rev()].splitlines()
class _chistedit_state(object):
def __init__(
self,
repo,
rules,
):
self.repo = repo
self.rules = rules
self.pos = 0
self.selected = None
self.mode = (MODE_INIT, MODE_INIT)
self.page_height = None
self.modes = {
MODE_RULES: {
b'line_offset': 0,
},
MODE_PATCH: {
b'line_offset': 0,
},
}
def _chisteditmain(repo, rules, stdscr): def _chisteditmain(repo, rules, stdscr):
try: try:
curses.use_default_colors() curses.use_default_colors()
except curses.error: except curses.error:
pass pass
# initialize color pattern # initialize color pattern
curses.init_pair(COLOR_HELP, curses.COLOR_WHITE, curses.COLOR_BLUE) curses.init_pair(COLOR_HELP, curses.COLOR_WHITE, curses.COLOR_BLUE)
try: try:
curses.curs_set(0) curses.curs_set(0)
except curses.error: except curses.error:
pass pass
def rendercommit(win, state): def rendercommit(win, state):
"""Renders the commit window that shows the log of the current selected """Renders the commit window that shows the log of the current selected
commit""" commit"""
pos = state[b'pos'] pos = state.pos
rules = state[b'rules'] rules = state.rules
rule = rules[pos] rule = rules[pos]
ctx = rule.ctx ctx = rule.ctx
win.box() win.box()
maxy, maxx = win.getmaxyx() maxy, maxx = win.getmaxyx()
length = maxx - 3 length = maxx - 3
?: help, k/up: move up, j/down: move down, space: select, v: view patch ?: help, k/up: move up, j/down: move down, space: select, v: view patch
d: drop, e: edit, f: fold, m: mess, p: pick, r: roll d: drop, e: edit, f: fold, m: mess, p: pick, r: roll
pgup/K: move patch up, pgdn/J: move patch down, c: commit, q: abort pgup/K: move patch up, pgdn/J: move patch down, c: commit, q: abort
""" """
return help.splitlines() return help.splitlines()
def renderhelp(win, state): def renderhelp(win, state):
maxy, maxx = win.getmaxyx() maxy, maxx = win.getmaxyx()
mode, _ = state[b'mode'] mode, _ = state.mode
for y, line in enumerate(helplines(mode)): for y, line in enumerate(helplines(mode)):
if y >= maxy: if y >= maxy:
break break
addln(win, y, 0, line, curses.color_pair(COLOR_HELP)) addln(win, y, 0, line, curses.color_pair(COLOR_HELP))
win.noutrefresh() win.noutrefresh()
def renderrules(rulesscr, state): def renderrules(rulesscr, state):
rules = state[b'rules'] rules = state.rules
pos = state[b'pos'] pos = state.pos
selected = state[b'selected'] selected = state.selected
start = state[b'modes'][MODE_RULES][b'line_offset'] start = state.modes[MODE_RULES][b'line_offset']
conflicts = [r.ctx for r in rules if r.conflicts] conflicts = [r.ctx for r in rules if r.conflicts]
if len(conflicts) > 0: if len(conflicts) > 0:
line = b"potential conflict in %s" % b','.join( line = b"potential conflict in %s" % b','.join(
map(pycompat.bytestr, conflicts) map(pycompat.bytestr, conflicts)
) )
addln(rulesscr, -1, 0, line, curses.color_pair(COLOR_WARN)) addln(rulesscr, -1, 0, line, curses.color_pair(COLOR_WARN))
for y, rule in enumerate(rules[start:]): for y, rule in enumerate(rules[start:]):
if y >= state[b'page_height']: if y >= state.page_height:
break break
if len(rule.conflicts) > 0: if len(rule.conflicts) > 0:
rulesscr.addstr(y, 0, b" ", curses.color_pair(COLOR_WARN)) rulesscr.addstr(y, 0, b" ", curses.color_pair(COLOR_WARN))
else: else:
rulesscr.addstr(y, 0, b" ", curses.COLOR_BLACK) rulesscr.addstr(y, 0, b" ", curses.COLOR_BLACK)
if y + start == selected: if y + start == selected:
rollcolor = COLOR_ROLL_SELECTED rollcolor = COLOR_ROLL_SELECTED
win.addstr(y, 0, line, curses.color_pair(COLOR_DIFF_OFFSET)) win.addstr(y, 0, line, curses.color_pair(COLOR_DIFF_OFFSET))
else: else:
win.addstr(y, 0, line) win.addstr(y, 0, line)
else: else:
win.addstr(y, 0, line) win.addstr(y, 0, line)
win.noutrefresh() win.noutrefresh()
def renderpatch(win, state): def renderpatch(win, state):
start = state[b'modes'][MODE_PATCH][b'line_offset'] start = state.modes[MODE_PATCH][b'line_offset']
content = state[b'modes'][MODE_PATCH][b'patchcontents'] content = state.modes[MODE_PATCH][b'patchcontents']
renderstring(win, state, content[start:], diffcolors=True) renderstring(win, state, content[start:], diffcolors=True)
def layout(mode): def layout(mode):
maxy, maxx = stdscr.getmaxyx() maxy, maxx = stdscr.getmaxyx()
helplen = len(helplines(mode)) helplen = len(helplines(mode))
mainlen = maxy - helplen - 12 mainlen = maxy - helplen - 12
if mainlen < 1: if mainlen < 1:
raise error.Abort( raise error.Abort(
b'main': (mainlen, maxx), b'main': (mainlen, maxx),
} }
def drawvertwin(size, y, x): def drawvertwin(size, y, x):
win = curses.newwin(size[0], size[1], y, x) win = curses.newwin(size[0], size[1], y, x)
y += size[0] y += size[0]
return win, y, x return win, y, x
state = { state = _chistedit_state(repo, rules)
b'pos': 0,
b'rules': rules,
b'selected': None,
b'mode': (MODE_INIT, MODE_INIT),
b'page_height': None,
b'modes': {
MODE_RULES: {
b'line_offset': 0,
},
MODE_PATCH: {
b'line_offset': 0,
},
},
b'repo': repo,
}
# eventloop # eventloop
ch = None ch = None
stdscr.clear() stdscr.clear()
stdscr.refresh() stdscr.refresh()
while True: while True:
oldmode, unused = state[b'mode'] oldmode, unused = state.mode
if oldmode == MODE_INIT: if oldmode == MODE_INIT:
changemode(state, MODE_RULES) changemode(state, MODE_RULES)
e = event(state, ch) e = event(state, ch)
if e == E_QUIT: if e == E_QUIT:
return False return False
if e == E_HISTEDIT: if e == E_HISTEDIT:
return state[b'rules'] return state.rules
else: else:
if e == E_RESIZE: if e == E_RESIZE:
size = screen_size() size = screen_size()
if size != stdscr.getmaxyx(): if size != stdscr.getmaxyx():
curses.resizeterm(*size) curses.resizeterm(*size)
curmode, unused = state[b'mode'] curmode, unused = state.mode
sizes = layout(curmode) sizes = layout(curmode)
if curmode != oldmode: if curmode != oldmode:
state[b'page_height'] = sizes[b'main'][0] state.page_height = sizes[b'main'][0]
# Adjust the view to fit the current screen size. # Adjust the view to fit the current screen size.
movecursor(state, state[b'pos'], state[b'pos']) movecursor(state, state.pos, state.pos)
# Pack the windows against the top, each pane spread across the # Pack the windows against the top, each pane spread across the
# full width of the screen. # full width of the screen.
y, x = (0, 0) y, x = (0, 0)
helpwin, y, x = drawvertwin(sizes[b'help'], y, x) helpwin, y, x = drawvertwin(sizes[b'help'], y, x)
mainwin, y, x = drawvertwin(sizes[b'main'], y, x) mainwin, y, x = drawvertwin(sizes[b'main'], y, x)
commitwin, y, x = drawvertwin(sizes[b'commit'], y, x) commitwin, y, x = drawvertwin(sizes[b'commit'], y, x)