def _checkoutlinelogwithedits(self): """() -> [str]. prompt all lines for edit""" alllines = self.linelog.getalllines() # header editortext = (_(b'HG: editing %s\nHG: "y" means the line to the right ' b'exists in the changeset to the top\nHG:\n') % self.fctxs[-1].path()) # [(idx, fctx)]. hide the dummy emptyfilecontext visiblefctxs = [(i, f) for i, f in enumerate(self.fctxs) if not isinstance(f, emptyfilecontext)] for i, (j, f) in enumerate(visiblefctxs): editortext += _(b'HG: %s/%s %s %s\n') % ( b'|' * i, b'-' * (len(visiblefctxs) - i + 1), short(f.node()), f.description().split(b'\n', 1)[0], ) editortext += _(b'HG: %s\n') % (b'|' * len(visiblefctxs)) # figure out the lifetime of a line, this is relatively inefficient, # but probably fine lineset = defaultdict(lambda: set()) # {(llrev, linenum): {llrev}} for i, f in visiblefctxs: self.linelog.annotate((i + 1) * 2) for l in self.linelog.annotateresult: lineset[l].add(i) # append lines for l in alllines: editortext += b' %s : %s' % ( b''.join([(b'y' if i in lineset[l] else b' ') for i, _f in visiblefctxs]), self._getline(l), ) # run editor editedtext = self.ui.edit(editortext, b'', action=b'absorb') if not editedtext: raise error.InputError(_(b'empty editor text')) # parse edited result contents = [b''] * len(self.fctxs) leftpadpos = 4 colonpos = leftpadpos + len(visiblefctxs) + 1 for l in mdiff.splitnewlines(editedtext): if l.startswith(b'HG:'): continue if l[colonpos - 1:colonpos + 2] != b' : ': raise error.InputError(_(b'malformed line: %s') % l) linecontent = l[colonpos + 2:] for i, ch in enumerate(pycompat.bytestr(l[leftpadpos:colonpos - 1])): if ch == b'y': contents[visiblefctxs[i][0]] += linecontent # chunkstats is hard to calculate if anything changes, therefore # set them to just a simple value (1, 1). if editedtext != editortext: self.chunkstats = [1, 1] return contents
def dosplit(ui, repo, tr, ctx, opts): committed = [] # [ctx] # Set working parent to ctx.p1(), and keep working copy as ctx's content if ctx.node() != repo.dirstate.p1(): hg.clean(repo, ctx.node(), show_stats=False) with repo.dirstate.parentchange(): scmutil.movedirstate(repo, ctx.p1()) # Any modified, added, removed, deleted result means split is incomplete def incomplete(repo): st = repo.status() return any((st.modified, st.added, st.removed, st.deleted)) # Main split loop while incomplete(repo): if committed: header = _(b'HG: Splitting %s. So far it has been split into:\n' ) % short(ctx.node()) # We don't want color codes in the commit message template, so # disable the label() template function while we render it. with ui.configoverride({(b'templatealias', b'label(l,x)'): b"x"}, b'split'): for c in committed: summary = cmdutil.format_changeset_summary(ui, c, b'split') header += _(b'HG: - %s\n') % summary header += _( b'HG: Write commit message for the next split changeset.\n') else: header = _(b'HG: Splitting %s. Write commit message for the ' b'first split changeset.\n') % short(ctx.node()) opts.update({ b'edit': True, b'interactive': True, b'message': header + ctx.description(), }) commands.commit(ui, repo, **pycompat.strkwargs(opts)) newctx = repo[b'.'] committed.append(newctx) if not committed: raise error.InputError(_(b'cannot split an empty revision')) scmutil.cleanupnodes( repo, {ctx.node(): [c.node() for c in committed]}, operation=b'split', fixphase=True, ) return committed[-1]
def trackedcmd(ui, repo, remotepath=None, *pats, **opts): """show or change the current narrowspec With no argument, shows the current narrowspec entries, one per line. Each line will be prefixed with 'I' or 'X' for included or excluded patterns, respectively. The narrowspec is comprised of expressions to match remote files and/or directories that should be pulled into your client. The narrowspec has *include* and *exclude* expressions, with excludes always trumping includes: that is, if a file matches an exclude expression, it will be excluded even if it also matches an include expression. Excluding files that were never included has no effect. Each included or excluded entry is in the format described by 'hg help patterns'. The options allow you to add or remove included and excluded expressions. If --clear is specified, then all previous includes and excludes are DROPPED and replaced by the new ones specified to --addinclude and --addexclude. If --clear is specified without any further options, the narrowspec will be empty and will not match any files. If --auto-remove-includes is specified, then those includes that don't match any files modified by currently visible local commits (those not shared by the remote) will be added to the set of explicitly specified includes to remove. --import-rules accepts a path to a file containing rules, allowing you to add --addinclude, --addexclude rules in bulk. Like the other include and exclude switches, the changes are applied immediately. """ opts = pycompat.byteskwargs(opts) if requirements.NARROW_REQUIREMENT not in repo.requirements: raise error.InputError( _(b'the tracked command is only supported on ' b'repositories cloned with --narrow')) # Before supporting, decide whether it "hg tracked --clear" should mean # tracking no paths or all paths. if opts[b'clear']: raise error.InputError(_(b'the --clear option is not yet supported')) # import rules from a file newrules = opts.get(b'import_rules') if newrules: try: filepath = os.path.join(encoding.getcwd(), newrules) fdata = util.readfile(filepath) except IOError as inst: raise error.StorageError( _(b"cannot read narrowspecs from '%s': %s") % (filepath, encoding.strtolocal(inst.strerror))) includepats, excludepats, profiles = sparse.parseconfig( ui, fdata, b'narrow') if profiles: raise error.InputError( _(b"including other spec files using '%include' " b"is not supported in narrowspec")) opts[b'addinclude'].extend(includepats) opts[b'addexclude'].extend(excludepats) addedincludes = narrowspec.parsepatterns(opts[b'addinclude']) removedincludes = narrowspec.parsepatterns(opts[b'removeinclude']) addedexcludes = narrowspec.parsepatterns(opts[b'addexclude']) removedexcludes = narrowspec.parsepatterns(opts[b'removeexclude']) autoremoveincludes = opts[b'auto_remove_includes'] update_working_copy = opts[b'update_working_copy'] only_show = not (addedincludes or removedincludes or addedexcludes or removedexcludes or newrules or autoremoveincludes or update_working_copy) oldincludes, oldexcludes = repo.narrowpats # filter the user passed additions and deletions into actual additions and # deletions of excludes and includes addedincludes -= oldincludes removedincludes &= oldincludes addedexcludes -= oldexcludes removedexcludes &= oldexcludes widening = addedincludes or removedexcludes narrowing = removedincludes or addedexcludes # Only print the current narrowspec. if only_show: ui.pager(b'tracked') fm = ui.formatter(b'narrow', opts) for i in sorted(oldincludes): fm.startitem() fm.write(b'status', b'%s ', b'I', label=b'narrow.included') fm.write(b'pat', b'%s\n', i, label=b'narrow.included') for i in sorted(oldexcludes): fm.startitem() fm.write(b'status', b'%s ', b'X', label=b'narrow.excluded') fm.write(b'pat', b'%s\n', i, label=b'narrow.excluded') fm.end() return 0 if update_working_copy: with repo.wlock(), repo.lock(), repo.transaction(b'narrow-wc'): narrowspec.updateworkingcopy(repo) narrowspec.copytoworkingcopy(repo) return 0 if not (widening or narrowing or autoremoveincludes): ui.status(_(b"nothing to widen or narrow\n")) return 0 with repo.wlock(), repo.lock(): cmdutil.bailifchanged(repo) # Find the revisions we have in common with the remote. These will # be used for finding local-only changes for narrowing. They will # also define the set of revisions to update for widening. remotepath = ui.expandpath(remotepath or b'default') url, branches = hg.parseurl(remotepath) ui.status(_(b'comparing with %s\n') % util.hidepassword(url)) remote = hg.peer(repo, opts, url) # check narrow support before doing anything if widening needs to be # performed. In future we should also abort if client is ellipses and # server does not support ellipses if widening and wireprototypes.NARROWCAP not in remote.capabilities(): raise error.Abort(_(b"server does not support narrow clones")) commoninc = discovery.findcommonincoming(repo, remote) if autoremoveincludes: outgoing = discovery.findcommonoutgoing(repo, remote, commoninc=commoninc) ui.status(_(b'looking for unused includes to remove\n')) localfiles = set() for n in itertools.chain(outgoing.missing, outgoing.excluded): localfiles.update(repo[n].files()) suggestedremovals = [] for include in sorted(oldincludes): match = narrowspec.match(repo.root, [include], oldexcludes) if not any(match(f) for f in localfiles): suggestedremovals.append(include) if suggestedremovals: for s in suggestedremovals: ui.status(b'%s\n' % s) if (ui.promptchoice( _(b'remove these unused includes (yn)?' b'$$ &Yes $$ &No')) == 0): removedincludes.update(suggestedremovals) narrowing = True else: ui.status(_(b'found no unused includes\n')) if narrowing: newincludes = oldincludes - removedincludes newexcludes = oldexcludes | addedexcludes _narrow( ui, repo, remote, commoninc, oldincludes, oldexcludes, newincludes, newexcludes, opts[b'force_delete_local_changes'], ) # _narrow() updated the narrowspec and _widen() below needs to # use the updated values as its base (otherwise removed includes # and addedexcludes will be lost in the resulting narrowspec) oldincludes = newincludes oldexcludes = newexcludes if widening: newincludes = oldincludes | addedincludes newexcludes = oldexcludes - removedexcludes _widen( ui, repo, remote, commoninc, oldincludes, oldexcludes, newincludes, newexcludes, ) return 0
def split(ui, repo, *revs, **opts): """split a changeset into smaller ones Repeatedly prompt changes and commit message for new changesets until there is nothing left in the original changeset. If --rev was not given, split the working directory parent. By default, rebase connected non-obsoleted descendants onto the new changeset. Use --no-rebase to avoid the rebase. """ opts = pycompat.byteskwargs(opts) revlist = [] if opts.get(b'rev'): revlist.append(opts.get(b'rev')) revlist.extend(revs) with repo.wlock(), repo.lock(), repo.transaction(b'split') as tr: revs = scmutil.revrange(repo, revlist or [b'.']) if len(revs) > 1: raise error.InputError(_(b'cannot split multiple revisions')) rev = revs.first() ctx = repo[rev] # Handle nullid specially here (instead of leaving for precheck() # below) so we get a nicer message and error code. if rev is None or ctx.node() == nullid: ui.status(_(b'nothing to split\n')) return 1 if ctx.node() is None: raise error.InputError(_(b'cannot split working directory')) if opts.get(b'rebase'): # Skip obsoleted descendants and their descendants so the rebase # won't cause conflicts for sure. descendants = list(repo.revs(b'(%d::) - (%d)', rev, rev)) torebase = list( repo.revs(b'%ld - (%ld & obsolete())::', descendants, descendants)) else: torebase = [] rewriteutil.precheck(repo, [rev] + torebase, b'split') if len(ctx.parents()) > 1: raise error.InputError(_(b'cannot split a merge changeset')) cmdutil.bailifchanged(repo) # Deactivate bookmark temporarily so it won't get moved unintentionally bname = repo._activebookmark if bname and repo._bookmarks[bname] != ctx.node(): bookmarks.deactivate(repo) wnode = repo[b'.'].node() top = None try: top = dosplit(ui, repo, tr, ctx, opts) finally: # top is None: split failed, need update --clean recovery. # wnode == ctx.node(): wnode split, no need to update. if top is None or wnode != ctx.node(): hg.clean(repo, wnode, show_stats=False) if bname: bookmarks.activate(repo, bname) if torebase and top: dorebase(ui, repo, torebase, top)
def absorb(ui, repo, stack=None, targetctx=None, pats=None, opts=None): """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. """ if stack is None: limit = ui.configint(b'absorb', b'max-stack-size') headctx = repo[b'.'] if len(headctx.parents()) > 1: raise error.InputError(_(b'cannot absorb into a merge')) stack = getdraftstack(headctx, limit) if limit and len(stack) >= limit: ui.warn( _(b'absorb: only the recent %d changesets will ' b'be analysed\n') % limit) if not stack: 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=opts) matcher = scmutil.match(targetctx, pats, opts) 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) fm = None if opts.get(b'print_changes') or not opts.get(b'apply_changes'): fm = ui.formatter(b'absorb', 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)) fm.data(linetype=b'summary') for ctx in reversed(stack): if ctx not in state.ctxaffected: continue fm.startitem() fm.context(ctx=ctx) fm.data(linetype=b'changeset') fm.write(b'node', b'%-7.7s ', ctx.hex(), label=b'absorb.node') descfirstline = ctx.description().splitlines()[0] fm.write( b'descfirstline', b'%s\n', descfirstline, label=b'absorb.description', ) fm.end() if not opts.get(b'dry_run'): if (not opts.get(b'apply_changes') and state.ctxaffected and ui.promptchoice(b"apply changes (y/N)? $$ &Yes $$ &No", default=1)): raise error.CanceledError(_(b'absorb cancelled\n')) state.apply() if state.commit(): state.printchunkstats() elif not ui.quiet: ui.write(_(b'nothing applied\n')) return state