mercurial: comparison hgext/absorb.py

equal deleted inserted replaced

-:788113f056d4
+:e0cae2b44191
 2. (optionally), present self.fixups to the user, or change it
 3. call apply, to apply changes
 4. read results from "finalcontents", or call getfinalcontent
 """
-def __init__(self, fctxs, path, ui=None, opts=None):
+def __init__(self, fctxs, path, ui=None, **opts):
 """([fctx], ui or None) -> None
 fctxs should be linear, and sorted by topo order - oldest first.
 fctxs[0] will be considered as "immutable" and will not be changed.
 """
 self.fctxs = fctxs
 self.path = path
 self.ui = ui or nullui()
-self.opts = opts or {}
+self.opts = opts
 # following fields are built from fctxs. they exist for perf reason
 self.contents = [f.data() for f in fctxs]
 self.contentlines = pycompat.maplist(mdiff.splitnewlines, self.contents)
 self.linelog = self._buildlinelog()
 self.ui.write(
 _(b'%s: chunk %d:%d -> %d lines\n')
 % (short(self.fctxs[idx].node()), a1, a2, len(blines))
 )
 self.linelog.replacelines(rev, a1, a2, b1, b2)
-if self.opts.get(b'edit_lines', False):
+if self.opts.get('edit_lines', False):
 self.finalcontents = self._checkoutlinelogwithedits()
 else:
 self.finalcontents = self._checkoutlinelog()
 def getfinalcontent(self, fctx):
 2. (optionally), present fixups to the user, or edit fixups
 3. call apply, to apply changes to memory
 4. call commit, to commit changes to hg database
 """
-def __init__(self, stack, ui=None, opts=None):
+def __init__(self, stack, ui=None, **opts):
 """([ctx], ui or None) -> None
 stack: should be linear, and sorted by topo order - oldest first.
 all commits in stack are considered mutable.
 """
 assert stack
 self.ui = ui or nullui()
-self.opts = opts or {}
+self.opts = opts
 self.stack = stack
 self.repo = stack[-1].repo().unfiltered()
 # following fields will be filled later
 self.paths = []  # [str]
 # only care about modified files
 self.status = self.stack[-1].status(targetctx, match)
 self.paths = []
 # but if --edit-lines is used, the user may want to edit files
 # even if they are not modified
-editopt = self.opts.get(b'edit_lines')
+editopt = self.opts.get('edit_lines')
 if not self.status.modified and editopt and match:
 interestingpaths = match.files()
 else:
 interestingpaths = self.status.modified
 # prepare the filefixupstate
 continue
 if targetfctx.data() == fctxs[-1].data() and not editopt:
 continue
 seenfctxs.update(fctxs[1:])
 self.fctxmap[path] = ctx2fctx
-fstate = filefixupstate(fctxs, path, ui=self.ui, opts=self.opts)
+fstate = filefixupstate(fctxs, path, ui=self.ui, **self.opts)
 if fm is not None:
 fm.startitem()
 fm.plain(b'showing changes for ')
 fm.write(b'path', b'%s\n', path, label=b'absorb.path')
 fm.data(linetype=b'path')
 lines[a1:a2] = blines
 memworkingcopy[path] = b''.join(lines)
 return overlaycontext(memworkingcopy, ctx)
-def absorb(ui, repo, stack=None, targetctx=None, pats=None, opts=None):
+def absorb(ui, repo, stack=None, targetctx=None, pats=None, **opts):
 """pick fixup chunks from targetctx, apply them to stack.
 if targetctx is None, the working copy context will be used.
 if stack is None, the current draft stack will be used.
 return fixupstate.
 raise error.InputError(_(b'no mutable changeset to change'))
 if targetctx is None:  # default to working copy
 targetctx = repo[None]
 if pats is None:
 pats = ()
-if opts is None:
-opts = {}
+state = fixupstate(stack, ui=ui, **opts)
-state = fixupstate(stack, ui=ui, opts=opts)
+matcher = scmutil.match(targetctx, pats, pycompat.byteskwargs(opts))
-matcher = scmutil.match(targetctx, pats, opts)
+if opts.get('interactive'):
-if opts.get(b'interactive'):
 diff = patch.diff(repo, stack[-1].node(), targetctx.node(), matcher)
 origchunks = patch.parsepatch(diff)
 chunks = cmdutil.recordfilter(ui, origchunks, matcher)[0]
 targetctx = overlaydiffcontext(stack[-1], chunks)
-if opts.get(b'edit_lines'):
+if opts.get('edit_lines'):
 # If we're going to open the editor, don't ask the user to confirm
 # first
-opts[b'apply_changes'] = True
+opts['apply_changes'] = True
 fm = None
-if opts.get(b'print_changes') or not opts.get(b'apply_changes'):
+if opts.get('print_changes') or not opts.get('apply_changes'):
-fm = ui.formatter(b'absorb', opts)
+fm = ui.formatter(b'absorb', pycompat.byteskwargs(opts))
 state.diffwith(targetctx, matcher, fm)
 if fm is not None:
 fm.startitem()
 fm.write(
 b"count", b"\n%d changesets affected\n", len(state.ctxaffected)
 b'%s\n',
 descfirstline,
 label=b'absorb.description',
 )
 fm.end()
-if not opts.get(b'dry_run'):
+if not opts.get('dry_run'):
 if (
-not opts.get(b'apply_changes')
+not opts.get('apply_changes')
 and state.ctxaffected
 and ui.promptchoice(
 b"apply changes (y/N)? $$ &Yes $$ &No", default=1
 )
 ):
 to the correct place, run :hg:`absorb -a` to apply the changes
 immediately.
 Returns 0 on success, 1 if all chunks were ignored and nothing amended.
 """
-opts = pycompat.byteskwargs(opts)
 with repo.wlock(), repo.lock():
-if not opts[b'dry_run']:
+if not opts['dry_run']:
 cmdutil.checkunfinished(repo)
-state = absorb(ui, repo, pats=pats, opts=opts)
+state = absorb(ui, repo, pats=pats, **opts)
 if sum(s[0] for s in state.chunkstats.values()) == 0:
 return 1

changeset 50869	e0cae2b44191
parent 49960	7a8bfc05b691
child 50928	d718eddf01d9