( )⚙ D11652 chistedit: remove some local variable and access state on self instead

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11652

chistedit: remove some local variable and access state on self instead
ClosedPublic

Authored by martinvonz on Oct 12 2021, 5:30 PM.

Details

Reviewers
durin42
pulkit
Group Reviewers
hg-reviewers
Commits
rHG1895027c5051: chistedit: remove some local variable and access state on self instead
Summary

Now that we've replaced the state dict by a class, some of the local
variables that just do foo = self.foo seem unnecessary.

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.

Revision Contents
Changeset List

PathPackages
Mhgext/histedit.py (43 lines)

Diff 30790

hgext/histedit.py

MODE_PATCH: { MODE_PATCH: {
b'line_offset': 0, b'line_offset': 0,
}, },
} }
def render_commit(self, win): def render_commit(self, win):
"""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 = self.pos rule = self.rules[self.pos]
rules = self.rules
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
line = b"changeset: %d:%s" % (ctx.rev(), ctx.hex()[:12]) line = b"changeset: %d:%s" % (ctx.rev(), ctx.hex()[:12])
) )
return { return {
b'commit': (12, maxx), b'commit': (12, maxx),
b'help': (helplen, maxx), b'help': (helplen, maxx),
b'main': (mainlen, maxx), b'main': (mainlen, maxx),
} }
def render_rules(self, rulesscr): def render_rules(self, rulesscr):
rules = self.rules
pos = self.pos
selected = self.selected
start = self.modes[MODE_RULES][b'line_offset'] start = self.modes[MODE_RULES][b'line_offset']
conflicts = [r.ctx for r in rules if r.conflicts] conflicts = [r.ctx for r in self.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(self.rules[start:]):
if y >= self.page_height: if y >= self.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 == self.selected:
rollcolor = COLOR_ROLL_SELECTED rollcolor = COLOR_ROLL_SELECTED
addln(rulesscr, y, 2, rule, curses.color_pair(COLOR_SELECTED)) addln(rulesscr, y, 2, rule, curses.color_pair(COLOR_SELECTED))
elif y + start == pos: elif y + start == self.pos:
rollcolor = COLOR_ROLL_CURRENT rollcolor = COLOR_ROLL_CURRENT
addln( addln(
rulesscr, rulesscr,
y, y,
2, 2,
rule, rule,
curses.color_pair(COLOR_CURRENT) | curses.A_BOLD, curses.color_pair(COLOR_CURRENT) | curses.A_BOLD,
) )
self.render_string(win, content[start:], diffcolors=True) self.render_string(win, content[start:], diffcolors=True)
def event(self, ch): def event(self, 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 = self.selected
oldpos = self.pos oldpos = self.pos
rules = self.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 = self.mode curmode, prevmode = self.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(self.rules) - 1)
self.move_cursor(oldpos, newpos) self.move_cursor(oldpos, newpos)
if selected is not None or action == b'move-down': if self.selected is not None or action == b'move-down':
self.swap(oldpos, newpos) self.swap(oldpos, newpos)
elif action in (b'up', b'move-up'): elif action in (b'up', b'move-up'):
newpos = max(0, oldpos - 1) newpos = max(0, oldpos - 1)
self.move_cursor(oldpos, newpos) self.move_cursor(oldpos, newpos)
if selected is not None or action == b'move-up': if self.selected is not None or action == b'move-up':
self.swap(oldpos, newpos) self.swap(oldpos, newpos)
elif action == b'next-action': elif action == b'next-action':
self.cycle_action(oldpos, next=True) self.cycle_action(oldpos, next=True)
elif action == b'prev-action': elif action == b'prev-action':
self.cycle_action(oldpos, next=False) self.cycle_action(oldpos, next=False)
elif action == b'select': elif action == b'select':
selected = oldpos if selected is None else None self.selected = oldpos if self.selected is None else None
self.make_selection(selected) self.make_selection(self.selected)
elif action == b'goto' and int(ch) < len(rules) and len(rules) <= 10: elif action == b'goto' and int(ch) < len(self.rules) <= 10:
newrule = next((r for r in rules if r.origpos == int(ch))) newrule = next((r for r in self.rules if r.origpos == int(ch)))
self.move_cursor(oldpos, newrule.pos) self.move_cursor(oldpos, newrule.pos)
if selected is not None: if self.selected is not None:
self.swap(oldpos, newrule.pos) self.swap(oldpos, newrule.pos)
elif action.startswith(b'action-'): elif action.startswith(b'action-'):
self.change_action(oldpos, action[7:]) self.change_action(oldpos, action[7:])
elif action == b'showpatch': elif action == b'showpatch':
self.change_mode(MODE_PATCH if curmode != MODE_PATCH else prevmode) self.change_mode(MODE_PATCH if curmode != MODE_PATCH else prevmode)
elif action == b'help': elif action == b'help':
self.change_mode(MODE_HELP if curmode != MODE_HELP else prevmode) self.change_mode(MODE_HELP if curmode != MODE_HELP else prevmode)
elif action == b'quit': elif action == b'quit':
rules[newpos].checkconflicts(rules[r]) rules[newpos].checkconflicts(rules[r])
rules[oldpos].checkconflicts(rules[r]) rules[oldpos].checkconflicts(rules[r])
if self.selected: if self.selected:
self.make_selection(newpos) self.make_selection(newpos)
def change_action(self, pos, action): def change_action(self, 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 = self.rules assert 0 <= pos < len(self.rules)
assert 0 <= pos < len(rules) self.rules[pos].action = action
rules[pos].action = action
def cycle_action(self, pos, next=False): def cycle_action(self, 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 = self.rules assert 0 <= pos < len(self.rules)
assert 0 <= pos < len(rules) current = self.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