This is an archive of the discontinued Mercurial Phabricator instance.

histedit: import chistedit curses UI from hg-experimental
ClosedPublic

Authored by durin42 on Oct 17 2018, 5:41 PM.

Download Raw Diff

Details

Reviewers

martinvonz
pulkit

Group Reviewers

hg-reviewers

Commits

rHGc36175456350: histedit: import chistedit curses UI from hg-experimental

Summary

I don't tend to like curses interfaces, but this gets enough use at
work that it seems like it's worth bringing into core. This is a
minimal import from hg-experimental revision 4c7f33bf5f00, in that
I've done the smallest amount of code movement and editing in order to
import the functionality.

.. feature::

`hg histedit` will now present a curses UI if curses is available
and `ui.interface` or `ui.interface.histedit` is set to `curses`.

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

durin42 created this revision.Oct 17 2018, 5:41 PM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptOct 17 2018, 5:41 PM

Herald added a subscriber: mercurial-devel. · View Herald Transcript

durin42 updated this revision to Diff 12221.Oct 17 2018, 6:11 PM

Is the goal is to include this in 4.8?

pulkit added a comment.
Is the goal is to include this in 4.8?

Yes if possible.

Would be good to have tests, but I guess there are no tests in hg-experimental either? I'm not queuing because I'm biased.

This revision is now accepted and ready to land.Oct 18 2018, 1:36 PM

Correct, no tests in hg-experimental. I did a basic sniff test, but I don't really know how we do curses tests in general.

durin42 updated this revision to Diff 12322.Oct 23 2018, 11:02 AM

I remember using chistedit and finding that the .hg/chisedit file is not deleted after chistedit is completed. Looking at code, I am unable to find code which deletes that file. Can you please have a look and delete that file after a successfull or aborted chistedit?

In D5146#77492, @pulkit wrote:

I remember using chistedit and finding that the .hg/chisedit file is not deleted after chistedit is completed. Looking at code, I am unable to find code which deletes that file. Can you please have a look and delete that file after a successfull or aborted chistedit?

That file is an implementation detail, so that histedit can pass rules to itself. It's a little gross, but not harmful.

Could I persuade you to let us clean that up later as a follow-up?

In D5146#77493, @durin42 wrote:

In D5146#77492, @pulkit wrote:

I remember using chistedit and finding that the .hg/chisedit file is not deleted after chistedit is completed. Looking at code, I am unable to find code which deletes that file. Can you please have a look and delete that file after a successfull or aborted chistedit?

That file is an implementation detail, so that histedit can pass rules to itself. It's a little gross, but not harmful.
Could I persuade you to let us clean that up later as a follow-up?

Yeah sure!

Queueing this, many thanks for importing this in core.

Can you add some documentation about the new config option to enable curses interface as followup?

Also, how do you feel about histedit using curses interface if ui.interface=curses is set?

Closed by commit rHGc36175456350: histedit: import chistedit curses UI from hg-experimental (authored by durin42). · Explain WhyNov 13 2018, 7:14 AM

This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

			Path	Packages
M			hgext/histedit.py (569 lines)
M			mercurial/ui.py (6 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	12220		Oct 17 2018, 5:41 PM	★	★
Diff 2	12221		Oct 17 2018, 6:11 PM	★	★
Diff 3	12322		Oct 23 2018, 11:02 AM	★	★
Diff 4	12513	rHGc3617545635031f1dc0634da5d251c8a69b7e9dc	Oct 17 2018, 5:15 PM	★	★

Diff 12513

hgext/histedit.py


	[histedit]			[histedit]
	singletransaction = True			singletransaction = True

	"""			"""

	from __future__ import absolute_import			from __future__ import absolute_import

				import fcntl
				import functools
	import os			import os
				import struct
				import termios

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial import (			from mercurial import (
	bundle2,			bundle2,
	cmdutil,			cmdutil,
	context,			context,
	copies,			copies,
	destutil,			destutil,
	discovery,			discovery,
	error,			error,
	exchange,			exchange,
	extensions,			extensions,
	hg,			hg,
	lock,			lock,
				logcmdutil,
	merge as mergemod,			merge as mergemod,
	mergeutil,			mergeutil,
	node,			node,
	obsolete,			obsolete,
	pycompat,			pycompat,
	registrar,			registrar,
	repair,			repair,
	scmutil,			scmutil,
	default=False,			default=False,
	)			)
	configitem('histedit', 'linelen',			configitem('histedit', 'linelen',
	default=80,			default=80,
	)			)
	configitem('histedit', 'singletransaction',			configitem('histedit', 'singletransaction',
	default=False,			default=False,
	)			)
				configitem('ui', 'interface.histedit',
				default=None,
				)

	# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for			# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
	# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should			# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
	# be specifying the version(s) of Mercurial they are tested with, or			# be specifying the version(s) of Mercurial they are tested with, or
	# leave the attribute unspecified.			# leave the attribute unspecified.
	testedwith = 'ships-with-hg-core'			testedwith = 'ships-with-hg-core'

	actiontable = {}			actiontable = {}
	raise error.Abort(_('no outgoing ancestors'))			raise error.Abort(_('no outgoing ancestors'))
	roots = list(repo.revs("roots(%ln)", outgoing.missing))			roots = list(repo.revs("roots(%ln)", outgoing.missing))
	if len(roots) > 1:			if len(roots) > 1:
	msg = _('there are ambiguous outgoing revisions')			msg = _('there are ambiguous outgoing revisions')
	hint = _("see 'hg help histedit' for more detail")			hint = _("see 'hg help histedit' for more detail")
	raise error.Abort(msg, hint=hint)			raise error.Abort(msg, hint=hint)
	return repo[roots[0]].node()			return repo[roots[0]].node()

				# Curses Support
				try:
				import curses
				except ImportError:
				curses = None

				KEY_LIST = ['pick', 'edit', 'fold', 'drop', 'mess', 'roll']
				ACTION_LABELS = {
				'fold': '^fold',
				'roll': '^roll',
				}

				COLOR_HELP, COLOR_SELECTED, COLOR_OK, COLOR_WARN = 1, 2, 3, 4

				E_QUIT, E_HISTEDIT = 1, 2
				E_PAGEDOWN, E_PAGEUP, E_LINEUP, E_LINEDOWN, E_RESIZE = 3, 4, 5, 6, 7
				MODE_INIT, MODE_PATCH, MODE_RULES, MODE_HELP = 0, 1, 2, 3

				KEYTABLE = {
				'global': {
				'h': 'next-action',
				'KEY_RIGHT': 'next-action',
				'l': 'prev-action',
				'KEY_LEFT': 'prev-action',
				'q': 'quit',
				'c': 'histedit',
				'C': 'histedit',
				'v': 'showpatch',
				'?': 'help',
				},
				MODE_RULES: {
				'd': 'action-drop',
				'e': 'action-edit',
				'f': 'action-fold',
				'm': 'action-mess',
				'p': 'action-pick',
				'r': 'action-roll',
				' ': 'select',
				'j': 'down',
				'k': 'up',
				'KEY_DOWN': 'down',
				'KEY_UP': 'up',
				'J': 'move-down',
				'K': 'move-up',
				'KEY_NPAGE': 'move-down',
				'KEY_PPAGE': 'move-up',
				'0': 'goto', # Used for 0..9
				},
				MODE_PATCH: {
				' ': 'page-down',
				'KEY_NPAGE': 'page-down',
				'KEY_PPAGE': 'page-up',
				'j': 'line-down',
				'k': 'line-up',
				'KEY_DOWN': 'line-down',
				'KEY_UP': 'line-up',
				'J': 'down',
				'K': 'up',
				},
				MODE_HELP: {
				},
				}

				def screen_size():
				return struct.unpack('hh', fcntl.ioctl(1, termios.TIOCGWINSZ, ' '))

				class histeditrule(object):
				def __init__(self, ctx, pos, action='pick'):
				self.ctx = ctx
				self.action = action
				self.origpos = pos
				self.pos = pos
				self.conflicts = []

				def __str__(self):
				# Some actions ('fold' and 'roll') combine a patch with a previous one.
				# Add a marker showing which patch they apply to, and also omit the
				# description for 'roll' (since it will get discarded). Example display:
				#
				# #10 pick 316392:06a16c25c053 add option to skip tests
				# #11 ^roll 316393:71313c964cc5
				# #12 pick 316394:ab31f3973b0d include mfbt for mozilla-config.h
				# #13 ^fold 316395:14ce5803f4c3 fix warnings
				#
				# The carets point to the changeset being folded into ("roll this
				# changeset into the changeset above").
				action = ACTION_LABELS.get(self.action, self.action)
				h = self.ctx.hex()[0:12]
				r = self.ctx.rev()
				desc = self.ctx.description().splitlines()[0].strip()
				if self.action == 'roll':
				desc = ''
				return "#{0:<2} {1:<6} {2}:{3} {4}".format(
				self.origpos, action, r, h, desc)

				def checkconflicts(self, other):
				if other.pos > self.pos and other.origpos <= self.origpos:
				if set(other.ctx.files()) & set(self.ctx.files()) != set():
				self.conflicts.append(other)
				return self.conflicts

				if other in self.conflicts:
				self.conflicts.remove(other)
				return self.conflicts

				# ============ EVENTS ===============
				def movecursor(state, oldpos, newpos):
				'''Change the rule/changeset that the cursor is pointing to, regardless of
				current mode (you can switch between patches from the view patch window).'''
				state['pos'] = newpos

				mode, _ = state['mode']
				if mode == MODE_RULES:
				# 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
				# result in the cursor's rule being visible.
				modestate = state['modes'][MODE_RULES]
				if newpos < modestate['line_offset']:
				modestate['line_offset'] = newpos
				elif newpos > modestate['line_offset'] + state['page_height'] - 1:
				modestate['line_offset'] = newpos - state['page_height'] + 1

				# Reset the patch view region to the top of the new patch.
				state['modes'][MODE_PATCH]['line_offset'] = 0

				def changemode(state, mode):
				curmode, _ = state['mode']
				state['mode'] = (mode, curmode)

				def makeselection(state, pos):
				state['selected'] = pos

				def swap(state, oldpos, newpos):
				"""Swap two positions and calculate necessary conflicts in
				O(\|newpos-oldpos\|) time"""

				rules = state['rules']
				assert 0 <= oldpos < len(rules) and 0 <= newpos < len(rules)

				rules[oldpos], rules[newpos] = rules[newpos], rules[oldpos]

				# TODO: swap should not know about histeditrule's internals
				rules[newpos].pos = newpos
				rules[oldpos].pos = oldpos

				start = min(oldpos, newpos)
				end = max(oldpos, newpos)
				for r in pycompat.xrange(start, end + 1):
				rules[newpos].checkconflicts(rules[r])
				rules[oldpos].checkconflicts(rules[r])

				if state['selected']:
				makeselection(state, newpos)

				def changeaction(state, pos, action):
				"""Change the action state on the given position to the new action"""
				rules = state['rules']
				assert 0 <= pos < len(rules)
				rules[pos].action = action

				def cycleaction(state, pos, next=False):
				"""Changes the action state the next or the previous action from
				the action list"""
				rules = state['rules']
				assert 0 <= pos < len(rules)
				current = rules[pos].action

				assert current in KEY_LIST

				index = KEY_LIST.index(current)
				if next:
				index += 1
				else:
				index -= 1
				changeaction(state, pos, KEY_LIST[index % len(KEY_LIST)])

				def changeview(state, delta, unit):
				'''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'.'''
				mode, _ = state['mode']
				if mode != MODE_PATCH:
				return
				mode_state = state['modes'][mode]
				num_lines = len(patchcontents(state))
				page_height = state['page_height']
				unit = page_height if unit == 'page' else 1
				num_pages = 1 + (num_lines - 1) / page_height
				max_offset = (num_pages - 1) * page_height
				newline = mode_state['line_offset'] + delta * unit
				mode_state['line_offset'] = max(0, min(max_offset, newline))

				def event(state, ch):
				"""Change state based on the current character input

				This takes the current state and based on the current character input from
				the user we change the state.
				"""
				selected = state['selected']
				oldpos = state['pos']
				rules = state['rules']

				if ch in (curses.KEY_RESIZE, "KEY_RESIZE"):
				return E_RESIZE

				lookup_ch = ch
				if '0' <= ch <= '9':
				lookup_ch = '0'

				curmode, prevmode = state['mode']
				action = KEYTABLE[curmode].get(lookup_ch, KEYTABLE['global'].get(lookup_ch))
				if action is None:
				return
				if action in ('down', 'move-down'):
				newpos = min(oldpos + 1, len(rules) - 1)
				movecursor(state, oldpos, newpos)
				if selected is not None or action == 'move-down':
				swap(state, oldpos, newpos)
				elif action in ('up', 'move-up'):
				newpos = max(0, oldpos - 1)
				movecursor(state, oldpos, newpos)
				if selected is not None or action == 'move-up':
				swap(state, oldpos, newpos)
				elif action == 'next-action':
				cycleaction(state, oldpos, next=True)
				elif action == 'prev-action':
				cycleaction(state, oldpos, next=False)
				elif action == 'select':
				selected = oldpos if selected is None else None
				makeselection(state, selected)
				elif action == 'goto' and int(ch) < len(rules) and len(rules) <= 10:
				newrule = next((r for r in rules if r.origpos == int(ch)))
				movecursor(state, oldpos, newrule.pos)
				if selected is not None:
				swap(state, oldpos, newrule.pos)
				elif action.startswith('action-'):
				changeaction(state, oldpos, action[7:])
				elif action == 'showpatch':
				changemode(state, MODE_PATCH if curmode != MODE_PATCH else prevmode)
				elif action == 'help':
				changemode(state, MODE_HELP if curmode != MODE_HELP else prevmode)
				elif action == 'quit':
				return E_QUIT
				elif action == 'histedit':
				return E_HISTEDIT
				elif action == 'page-down':
				return E_PAGEDOWN
				elif action == 'page-up':
				return E_PAGEUP
				elif action == 'line-down':
				return E_LINEDOWN
				elif action == 'line-up':
				return E_LINEUP

				def makecommands(rules):
				"""Returns a list of commands consumable by histedit --commands based on
				our list of rules"""
				commands = []
				for rules in rules:
				commands.append("{0} {1}\n".format(rules.action, rules.ctx))
				return commands

				def addln(win, y, x, line, color=None):
				"""Add a line to the given window left padding but 100% filled with
				whitespace characters, so that the color appears on the whole line"""
				maxy, maxx = win.getmaxyx()
				length = maxx - 1 - x
				line = ("{0:<%d}" % length).format(str(line).strip())[:length]
				if y < 0:
				y = maxy + y
				if x < 0:
				x = maxx + x
				if color:
				win.addstr(y, x, line, color)
				else:
				win.addstr(y, x, line)

				def patchcontents(state):
				repo = state['repo']
				rule = state['rules'][state['pos']]
				displayer = logcmdutil.changesetdisplayer(repo.ui, repo, {
				'patch': True, 'verbose': True
				}, buffered=True)
				displayer.show(rule.ctx)
				displayer.close()
				return displayer.hunk[rule.ctx.rev()].splitlines()

				def _chisteditmain(repo, rules, stdscr):
				# initialize color pattern
				curses.init_pair(COLOR_HELP, curses.COLOR_WHITE, curses.COLOR_BLUE)
				curses.init_pair(COLOR_SELECTED, curses.COLOR_BLACK, curses.COLOR_WHITE)
				curses.init_pair(COLOR_WARN, curses.COLOR_BLACK, curses.COLOR_YELLOW)
				curses.init_pair(COLOR_OK, curses.COLOR_BLACK, curses.COLOR_GREEN)

				# don't display the cursor
				try:
				curses.curs_set(0)
				except curses.error:
				pass

				def rendercommit(win, state):
				"""Renders the commit window that shows the log of the current selected
				commit"""
				pos = state['pos']
				rules = state['rules']
				rule = rules[pos]

				ctx = rule.ctx
				win.box()

				maxy, maxx = win.getmaxyx()
				length = maxx - 3

				line = "changeset: {0}:{1:<12}".format(ctx.rev(), ctx)
				win.addstr(1, 1, line[:length])

				line = "user: {0}".format(stringutil.shortuser(ctx.user()))
				win.addstr(2, 1, line[:length])

				bms = repo.nodebookmarks(ctx.node())
				line = "bookmark: {0}".format(' '.join(bms))
				win.addstr(3, 1, line[:length])

				line = "files: {0}".format(','.join(ctx.files()))
				win.addstr(4, 1, line[:length])

				line = "summary: {0}".format(ctx.description().splitlines()[0])
				win.addstr(5, 1, line[:length])

				conflicts = rule.conflicts
				if len(conflicts) > 0:
				conflictstr = ','.join(map(lambda r: str(r.ctx), conflicts))
				conflictstr = "changed files overlap with {0}".format(conflictstr)
				else:
				conflictstr = 'no overlap'

				win.addstr(6, 1, conflictstr[:length])
				win.noutrefresh()

				def helplines(mode):
				if mode == MODE_PATCH:
				help = """\
				?: help, k/up: line up, j/down: line down, v: stop viewing patch
				pgup: prev page, space/pgdn: next page, c: commit, q: abort
				"""
				else:
				help = """\
				?: 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
				pgup/K: move patch up, pgdn/J: move patch down, c: commit, q: abort
				"""
				return help.splitlines()

				def renderhelp(win, state):
				maxy, maxx = win.getmaxyx()
				mode, _ = state['mode']
				for y, line in enumerate(helplines(mode)):
				if y >= maxy:
				break
				addln(win, y, 0, line, curses.color_pair(COLOR_HELP))
				win.noutrefresh()

				def renderrules(rulesscr, state):
				rules = state['rules']
				pos = state['pos']
				selected = state['selected']
				start = state['modes'][MODE_RULES]['line_offset']

				conflicts = [r.ctx for r in rules if r.conflicts]
				if len(conflicts) > 0:
				line = "potential conflict in %s" % ','.join(map(str, conflicts))
				addln(rulesscr, -1, 0, line, curses.color_pair(COLOR_WARN))

				for y, rule in enumerate(rules[start:]):
				if y >= state['page_height']:
				break
				if len(rule.conflicts) > 0:
				rulesscr.addstr(y, 0, " ", curses.color_pair(COLOR_WARN))
				else:
				rulesscr.addstr(y, 0, " ", curses.COLOR_BLACK)
				if y + start == selected:
				addln(rulesscr, y, 2, rule, curses.color_pair(COLOR_SELECTED))
				elif y + start == pos:
				addln(rulesscr, y, 2, rule, curses.A_BOLD)
				else:
				addln(rulesscr, y, 2, rule)
				rulesscr.noutrefresh()

				def renderstring(win, state, output):
				maxy, maxx = win.getmaxyx()
				length = min(maxy - 1, len(output))
				for y in range(0, length):
				win.addstr(y, 0, output[y])
				win.noutrefresh()

				def renderpatch(win, state):
				start = state['modes'][MODE_PATCH]['line_offset']
				renderstring(win, state, patchcontents(state)[start:])

				def layout(mode):
				maxy, maxx = stdscr.getmaxyx()
				helplen = len(helplines(mode))
				return {
				'commit': (8, maxx),
				'help': (helplen, maxx),
				'main': (maxy - helplen - 8, maxx),
				}

				def drawvertwin(size, y, x):
				win = curses.newwin(size[0], size[1], y, x)
				y += size[0]
				return win, y, x

				state = {
				'pos': 0,
				'rules': rules,
				'selected': None,
				'mode': (MODE_INIT, MODE_INIT),
				'page_height': None,
				'modes': {
				MODE_RULES: {
				'line_offset': 0,
				},
				MODE_PATCH: {
				'line_offset': 0,
				}
				},
				'repo': repo,
				}

				# eventloop
				ch = None
				stdscr.clear()
				stdscr.refresh()
				while True:
				try:
				oldmode, _ = state['mode']
				if oldmode == MODE_INIT:
				changemode(state, MODE_RULES)
				e = event(state, ch)

				if e == E_QUIT:
				return False
				if e == E_HISTEDIT:
				return state['rules']
				else:
				if e == E_RESIZE:
				size = screen_size()
				if size != stdscr.getmaxyx():
				curses.resizeterm(*size)

				curmode, _ = state['mode']
				sizes = layout(curmode)
				if curmode != oldmode:
				state['page_height'] = sizes['main'][0]
				# Adjust the view to fit the current screen size.
				movecursor(state, state['pos'], state['pos'])

				# Pack the windows against the top, each pane spread across the
				# full width of the screen.
				y, x = (0, 0)
				helpwin, y, x = drawvertwin(sizes['help'], y, x)
				mainwin, y, x = drawvertwin(sizes['main'], y, x)
				commitwin, y, x = drawvertwin(sizes['commit'], y, x)

				if e in (E_PAGEDOWN, E_PAGEUP, E_LINEDOWN, E_LINEUP):
				if e == E_PAGEDOWN:
				changeview(state, +1, 'page')
				elif e == E_PAGEUP:
				changeview(state, -1, 'page')
				elif e == E_LINEDOWN:
				changeview(state, +1, 'line')
				elif e == E_LINEUP:
				changeview(state, -1, 'line')

				# start rendering
				commitwin.erase()
				helpwin.erase()
				mainwin.erase()
				if curmode == MODE_PATCH:
				renderpatch(mainwin, state)
				elif curmode == MODE_HELP:
				renderstring(mainwin, state, __doc__.strip().splitlines())
				else:
				renderrules(mainwin, state)
				rendercommit(commitwin, state)
				renderhelp(helpwin, state)
				curses.doupdate()
				# done rendering
				ch = stdscr.getkey()
				except curses.error:
				pass

				def _chistedit(ui, repo, freeargs, *opts):
				"""interactively edit changeset history via a curses interface

				Provides a ncurses interface to histedit. Press ? in chistedit mode
				to see an extensive help. Requires python-curses to be installed."""

				if curses is None:
				raise error.Abort(_("Python curses library required"))

				# disable color
				ui._colormode = None

				try:
				keep = opts.get('keep')
				revs = opts.get('rev', [])[:]
				cmdutil.checkunfinished(repo)
				cmdutil.bailifchanged(repo)

				if os.path.exists(os.path.join(repo.path, 'histedit-state')):
				raise error.Abort(_('history edit already in progress, try '
				'--continue or --abort'))
				revs.extend(freeargs)
				if not revs:
				defaultrev = destutil.desthistedit(ui, repo)
				if defaultrev is not None:
				revs.append(defaultrev)
				if len(revs) != 1:
				raise error.Abort(
				_('histedit requires exactly one ancestor revision'))

				rr = list(repo.set('roots(%ld)', scmutil.revrange(repo, revs)))
				if len(rr) != 1:
				raise error.Abort(_('The specified revisions must have '
				'exactly one common root'))
				root = rr[0].node()

				topmost, empty = repo.dirstate.parents()
				revs = between(repo, root, topmost, keep)
				if not revs:
				raise error.Abort(_('%s is not an ancestor of working directory') %
				node.short(root))

				ctxs = []
				for i, r in enumerate(revs):
				ctxs.append(histeditrule(repo[r], i))
				rc = curses.wrapper(functools.partial(_chisteditmain, repo, ctxs))
				curses.echo()
				curses.endwin()
				if rc is False:
				ui.write(_("chistedit aborted\n"))
				return 0
				if type(rc) is list:
				ui.status(_("running histedit\n"))
				rules = makecommands(rc)
				filename = repo.vfs.join('chistedit')
				with open(filename, 'w+') as fp:
				for r in rules:
				fp.write(r)
				opts['commands'] = filename
				return _texthistedit(ui, repo, freeargs, *opts)
				except KeyboardInterrupt:
				pass
				return -1

	@command('histedit',			@command('histedit',
	[('', 'commands', '',			[('', 'commands', '',
	_('read history edits from the specified file'), _('FILE')),			_('read history edits from the specified file'), _('FILE')),
	('c', 'continue', False, _('continue an edit already in progress')),			('c', 'continue', False, _('continue an edit already in progress')),
	('', 'edit-plan', False, _('edit remaining actions list')),			('', 'edit-plan', False, _('edit remaining actions list')),
	('k', 'keep', False,			('k', 'keep', False,
	_("don't strip old nodes after edit is complete")),			_("don't strip old nodes after edit is complete")),
	('', 'abort', False, _('abort an edit in progress')),			('', 'abort', False, _('abort an edit in progress')),
	pick 8ef592ce7cc4 4 Bedazzle the zerlog			pick 8ef592ce7cc4 4 Bedazzle the zerlog
	pick 5339bf82f0ca 3 Zworgle the foobar			pick 5339bf82f0ca 3 Zworgle the foobar
	pick 252a1af424ad 2 Blorb a morgwazzle			pick 252a1af424ad 2 Blorb a morgwazzle

	Returns 0 on success, 1 if user intervention is required (not only			Returns 0 on success, 1 if user intervention is required (not only
	for intentional "edit" command, but also for resolving unexpected			for intentional "edit" command, but also for resolving unexpected
	conflicts).			conflicts).
	"""			"""
				if ui.interface('histedit') == 'curses':
				return _chistedit(ui, repo, freeargs, *opts)
				return _texthistedit(ui, repo, freeargs, *opts)

				def _texthistedit(ui, repo, freeargs, *opts):
	state = histeditstate(repo)			state = histeditstate(repo)
	try:			try:
	state.wlock = repo.wlock()			state.wlock = repo.wlock()
	state.lock = repo.lock()			state.lock = repo.lock()
	_histedit(ui, repo, state, freeargs, *opts)			_histedit(ui, repo, state, freeargs, *opts)
	finally:			finally:
	release(state.lock, state.wlock)			release(state.lock, state.wlock)

mercurial/ui.py

	the default curses interface (crecord at the moment).			the default curses interface (crecord at the moment).
	"""			"""
	alldefaults = frozenset(["text", "curses"])			alldefaults = frozenset(["text", "curses"])

	featureinterfaces = {			featureinterfaces = {
	"chunkselector": [			"chunkselector": [
	"text",			"text",
	"curses",			"curses",
	]			],
				"histedit": [
				"text",
				"curses",
				],
	}			}

	# Feature-specific interface			# Feature-specific interface
	if feature not in featureinterfaces.keys():			if feature not in featureinterfaces.keys():
	# Programming error, not user error			# Programming error, not user error
	raise ValueError("Unknown feature requested %s" % feature)			raise ValueError("Unknown feature requested %s" % feature)

	availableinterfaces = frozenset(featureinterfaces[feature])			availableinterfaces = frozenset(featureinterfaces[feature])