mercurial-scm/hg: comparison mercurial/destutil.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 # and the usual case (len = 1)
 successors = [n for sub in successors for n in sub]
 # get the max revision for the given successors set,
 # i.e. the 'tip' of a set
-node = repo.revs('max(%ln)', successors).first()
+node = repo.revs(b'max(%ln)', successors).first()
 if bookmarks.isactivewdirparent(repo):
-movemark = repo['.'].node()
+movemark = repo[b'.'].node()
 return node, movemark, None
 def _destupdatebook(repo, clean):
 """decide on an update destination from active bookmark"""
 wc = repo[None]
 movemark = node = None
 currentbranch = wc.branch()
 if clean:
-currentbranch = repo['.'].branch()
+currentbranch = repo[b'.'].branch()
 if currentbranch in repo.branchmap():
 heads = repo.branchheads(currentbranch)
 if heads:
-node = repo.revs('max(.::(%ln))', heads).first()
+node = repo.revs(b'max(.::(%ln))', heads).first()
 if bookmarks.isactivewdirparent(repo):
-movemark = repo['.'].node()
+movemark = repo[b'.'].node()
-elif currentbranch == 'default' and not wc.p1():
+elif currentbranch == b'default' and not wc.p1():
 # "null" parent belongs to "default" branch, but it doesn't exist, so
 # update to the tipmost non-closed branch head
-node = repo.revs('max(head() and not closed())').first()
+node = repo.revs(b'max(head() and not closed())').first()
 else:
-node = repo['.'].node()
+node = repo[b'.'].node()
 return node, movemark, None
 def _destupdatebranchfallback(repo, clean):
 """decide on an update destination from closed heads in current branch"""
 currentbranch = wc.branch()
 movemark = None
 if currentbranch in repo.branchmap():
 # here, all descendant branch heads are closed
 heads = repo.branchheads(currentbranch, closed=True)
-assert heads, "any branch has at least one head"
+assert heads, b"any branch has at least one head"
-node = repo.revs('max(.::(%ln))', heads).first()
+node = repo.revs(b'max(.::(%ln))', heads).first()
 assert node is not None, (
-"any revision has at least " "one descendant branch head"
+b"any revision has at least " b"one descendant branch head"
 )
 if bookmarks.isactivewdirparent(repo):
-movemark = repo['.'].node()
+movemark = repo[b'.'].node()
 else:
 # here, no "default" branch, and all branches are closed
-node = repo.lookup('tip')
+node = repo.lookup(b'tip')
-assert node is not None, "'tip' exists even in empty repository"
+assert node is not None, b"'tip' exists even in empty repository"
 return node, movemark, None
 # order in which each step should be evaluated
 # steps are run until one finds a destination
-destupdatesteps = ['evolution', 'bookmark', 'branch', 'branchfallback']
+destupdatesteps = [b'evolution', b'bookmark', b'branch', b'branchfallback']
 # mapping to ease extension overriding steps.
 destupdatestepmap = {
-'evolution': _destupdateobs,
+b'evolution': _destupdateobs,
-'bookmark': _destupdatebook,
+b'bookmark': _destupdatebook,
-'branch': _destupdatebranch,
+b'branch': _destupdatebranch,
-'branchfallback': _destupdatebranchfallback,
+b'branchfallback': _destupdatebranchfallback,
 }
 def destupdate(repo, clean=False):
 """destination for bare update operation
 return rev, movemark, activemark
 msgdestmerge = {
 # too many matching divergent bookmark
-'toomanybookmarks': {
+b'toomanybookmarks': {
-'merge': (
+b'merge': (
 _(
-"multiple matching bookmarks to merge -"
+b"multiple matching bookmarks to merge -"
-" please merge with an explicit rev or bookmark"
+b" please merge with an explicit rev or bookmark"
 ),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
-'rebase': (
+b'rebase': (
 _(
-"multiple matching bookmarks to rebase -"
+b"multiple matching bookmarks to rebase -"
-" please rebase to an explicit rev or bookmark"
+b" please rebase to an explicit rev or bookmark"
 ),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
 },
 # no other matching divergent bookmark
-'nootherbookmarks': {
+b'nootherbookmarks': {
-'merge': (
+b'merge': (
 _(
-"no matching bookmark to merge - "
+b"no matching bookmark to merge - "
-"please merge with an explicit rev or bookmark"
+b"please merge with an explicit rev or bookmark"
 ),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
-'rebase': (
+b'rebase': (
 _(
-"no matching bookmark to rebase - "
+b"no matching bookmark to rebase - "
-"please rebase to an explicit rev or bookmark"
+b"please rebase to an explicit rev or bookmark"
 ),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
 },
 # branch have too many unbookmarked heads, no obvious destination
-'toomanyheads': {
+b'toomanyheads': {
-'merge': (
+b'merge': (
-_("branch '%s' has %d heads - please merge with an explicit rev"),
+_(b"branch '%s' has %d heads - please merge with an explicit rev"),
-_("run 'hg heads .' to see heads"),
+_(b"run 'hg heads .' to see heads"),
 ),
-'rebase': (
+b'rebase': (
-_("branch '%s' has %d heads - please rebase to an explicit rev"),
+_(b"branch '%s' has %d heads - please rebase to an explicit rev"),
-_("run 'hg heads .' to see heads"),
+_(b"run 'hg heads .' to see heads"),
 ),
 },
 # branch have no other unbookmarked heads
-'bookmarkedheads': {
+b'bookmarkedheads': {
-'merge': (
+b'merge': (
-_("heads are bookmarked - please merge with an explicit rev"),
+_(b"heads are bookmarked - please merge with an explicit rev"),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
-'rebase': (
+b'rebase': (
-_("heads are bookmarked - please rebase to an explicit rev"),
+_(b"heads are bookmarked - please rebase to an explicit rev"),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
 },
 # branch have just a single heads, but there is other branches
-'nootherbranchheads': {
+b'nootherbranchheads': {
-'merge': (
+b'merge': (
-_("branch '%s' has one head - please merge with an explicit rev"),
+_(b"branch '%s' has one head - please merge with an explicit rev"),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
-'rebase': (
+b'rebase': (
-_("branch '%s' has one head - please rebase to an explicit rev"),
+_(b"branch '%s' has one head - please rebase to an explicit rev"),
-_("run 'hg heads' to see all heads"),
+_(b"run 'hg heads' to see all heads"),
 ),
 },
 # repository have a single head
-'nootherheads': {
+b'nootherheads': {
-'merge': (_('nothing to merge'), None),
+b'merge': (_(b'nothing to merge'), None),
-'rebase': (_('nothing to rebase'), None),
+b'rebase': (_(b'nothing to rebase'), None),
 },
 # repository have a single head and we are not on it
-'nootherheadsbehind': {
+b'nootherheadsbehind': {
-'merge': (_('nothing to merge'), _("use 'hg update' instead")),
+b'merge': (_(b'nothing to merge'), _(b"use 'hg update' instead")),
-'rebase': (_('nothing to rebase'), _("use 'hg update' instead")),
+b'rebase': (_(b'nothing to rebase'), _(b"use 'hg update' instead")),
 },
 # We are not on a head
-'notatheads': {
+b'notatheads': {
-'merge': (
+b'merge': (
-_('working directory not at a head revision'),
+_(b'working directory not at a head revision'),
-_("use 'hg update' or merge with an explicit revision"),
+_(b"use 'hg update' or merge with an explicit revision"),
 ),
-'rebase': (
+b'rebase': (
-_('working directory not at a head revision'),
+_(b'working directory not at a head revision'),
-_("use 'hg update' or rebase to an explicit revision"),
+_(b"use 'hg update' or rebase to an explicit revision"),
 ),
 },
-'emptysourceset': {
+b'emptysourceset': {
-'merge': (_('source set is empty'), None),
+b'merge': (_(b'source set is empty'), None),
-'rebase': (_('source set is empty'), None),
+b'rebase': (_(b'source set is empty'), None),
 },
-'multiplebranchessourceset': {
+b'multiplebranchessourceset': {
-'merge': (_('source set is rooted in multiple branches'), None),
+b'merge': (_(b'source set is rooted in multiple branches'), None),
-'rebase': (
+b'rebase': (
-_('rebaseset is rooted in multiple named branches'),
+_(b'rebaseset is rooted in multiple named branches'),
-_('specify an explicit destination with --dest'),
+_(b'specify an explicit destination with --dest'),
 ),
 },
 }
-def _destmergebook(repo, action='merge', sourceset=None, destspace=None):
+def _destmergebook(repo, action=b'merge', sourceset=None, destspace=None):
 """find merge destination in the active bookmark case"""
 node = None
 bmheads = bookmarks.headsforactive(repo)
 curhead = repo._bookmarks[repo._activebookmark]
 if len(bmheads) == 2:
 if curhead == bmheads[0]:
 node = bmheads[1]
 else:
 node = bmheads[0]
 elif len(bmheads) > 2:
-msg, hint = msgdestmerge['toomanybookmarks'][action]
+msg, hint = msgdestmerge[b'toomanybookmarks'][action]
 raise error.ManyMergeDestAbort(msg, hint=hint)
 elif len(bmheads) <= 1:
-msg, hint = msgdestmerge['nootherbookmarks'][action]
+msg, hint = msgdestmerge[b'nootherbookmarks'][action]
 raise error.NoMergeDestAbort(msg, hint=hint)
 assert node is not None
 return node
 def _destmergebranch(
-repo, action='merge', sourceset=None, onheadcheck=True, destspace=None
+repo, action=b'merge', sourceset=None, onheadcheck=True, destspace=None
 ):
 """find merge destination based on branch heads"""
 node = None
 if sourceset is None:
 sourceset = [repo[repo.dirstate.p1()].rev()]
 branch = repo.dirstate.branch()
 elif not sourceset:
-msg, hint = msgdestmerge['emptysourceset'][action]
+msg, hint = msgdestmerge[b'emptysourceset'][action]
 raise error.NoMergeDestAbort(msg, hint=hint)
 else:
 branch = None
-for ctx in repo.set('roots(%ld::%ld)', sourceset, sourceset):
+for ctx in repo.set(b'roots(%ld::%ld)', sourceset, sourceset):
 if branch is not None and ctx.branch() != branch:
-msg, hint = msgdestmerge['multiplebranchessourceset'][action]
+msg, hint = msgdestmerge[b'multiplebranchessourceset'][action]
 raise error.ManyMergeDestAbort(msg, hint=hint)
 branch = ctx.branch()
 bheads = repo.branchheads(branch)
-onhead = repo.revs('%ld and %ln', sourceset, bheads)
+onhead = repo.revs(b'%ld and %ln', sourceset, bheads)
 if onheadcheck and not onhead:
 # Case A: working copy if not on a head. (merge only)
 #
 # This is probably a user mistake We bailout pointing at 'hg update'
 if len(repo.heads()) <= 1:
-msg, hint = msgdestmerge['nootherheadsbehind'][action]
+msg, hint = msgdestmerge[b'nootherheadsbehind'][action]
 else:
-msg, hint = msgdestmerge['notatheads'][action]
+msg, hint = msgdestmerge[b'notatheads'][action]
 raise error.Abort(msg, hint=hint)
 # remove heads descendants of source from the set
-bheads = list(repo.revs('%ln - (%ld::)', bheads, sourceset))
+bheads = list(repo.revs(b'%ln - (%ld::)', bheads, sourceset))
 # filters out bookmarked heads
-nbhs = list(repo.revs('%ld - bookmark()', bheads))
+nbhs = list(repo.revs(b'%ld - bookmark()', bheads))
 if destspace is not None:
 # restrict search space
 # used in the 'hg pull --rebase' case, see issue 5214.
-nbhs = list(repo.revs('%ld and %ld', destspace, nbhs))
+nbhs = list(repo.revs(b'%ld and %ld', destspace, nbhs))
 if len(nbhs) > 1:
 # Case B: There is more than 1 other anonymous heads
 #
 # This means that there will be more than 1 candidate. This is
 # ambiguous. We abort asking the user to pick as explicit destination
 # instead.
-msg, hint = msgdestmerge['toomanyheads'][action]
+msg, hint = msgdestmerge[b'toomanyheads'][action]
 msg %= (branch, len(bheads) + 1)
 raise error.ManyMergeDestAbort(msg, hint=hint)
 elif not nbhs:
 # Case B: There is no other anonymous heads
 #
 # This means that there is no natural candidate to merge with.
 # We abort, with various messages for various cases.
 if bheads:
-msg, hint = msgdestmerge['bookmarkedheads'][action]
+msg, hint = msgdestmerge[b'bookmarkedheads'][action]
 elif len(repo.heads()) > 1:
-msg, hint = msgdestmerge['nootherbranchheads'][action]
+msg, hint = msgdestmerge[b'nootherbranchheads'][action]
 msg %= branch
 elif not onhead:
 # if 'onheadcheck == False' (rebase case),
 # this was not caught in Case A.
-msg, hint = msgdestmerge['nootherheadsbehind'][action]
+msg, hint = msgdestmerge[b'nootherheadsbehind'][action]
 else:
-msg, hint = msgdestmerge['nootherheads'][action]
+msg, hint = msgdestmerge[b'nootherheads'][action]
 raise error.NoMergeDestAbort(msg, hint=hint)
 else:
 node = nbhs[0]
 assert node is not None
 return node
 def destmerge(
-repo, action='merge', sourceset=None, onheadcheck=True, destspace=None
+repo, action=b'merge', sourceset=None, onheadcheck=True, destspace=None
 ):
 """return the default destination for a merge
 (or raise exception about why it can't pick one)
 return repo[node].rev()
 def desthistedit(ui, repo):
 """Default base revision to edit for `hg histedit`."""
-default = ui.config('histedit', 'defaultrev')
+default = ui.config(b'histedit', b'defaultrev')
 if default is None:
 revs = stack.getstack(repo)
 elif default:
 revs = scmutil.revrange(repo, [default])
 else:
-raise error.Abort(_("config option histedit.defaultrev can't be empty"))
+raise error.Abort(
+_(b"config option histedit.defaultrev can't be empty")
+)
 if revs:
 # Take the first revision of the revset as the root
 return revs.min()
 def _statusotherbook(ui, repo):
 bmheads = bookmarks.headsforactive(repo)
 curhead = repo._bookmarks[repo._activebookmark]
-if repo.revs('%n and parents()', curhead):
+if repo.revs(b'%n and parents()', curhead):
 # we are on the active bookmark
 bmheads = [b for b in bmheads if curhead != b]
 if bmheads:
-msg = _('%i other divergent bookmarks for "%s"\n')
+msg = _(b'%i other divergent bookmarks for "%s"\n')
 ui.status(msg % (len(bmheads), repo._activebookmark))
 def _statusotherbranchheads(ui, repo):
 currentbranch = repo.dirstate.branch()
 allheads = repo.branchheads(currentbranch, closed=True)
 heads = repo.branchheads(currentbranch)
-if repo.revs('%ln and parents()', allheads):
+if repo.revs(b'%ln and parents()', allheads):
 # we are on a head, even though it might be closed
 #
 #  on closed otherheads
 #  ========= ==========
 #      o        0       all heads for current branch are closed
 #               N       only descendant branch heads are closed
 #      x        0       there is only one non-closed branch head
 #               N       there are some non-closed branch heads
 #  ========= ==========
-otherheads = repo.revs('%ln - parents()', heads)
+otherheads = repo.revs(b'%ln - parents()', heads)
-if repo['.'].closesbranch():
+if repo[b'.'].closesbranch():
 ui.warn(
 _(
-'no open descendant heads on branch "%s", '
+b'no open descendant heads on branch "%s", '
-'updating to a closed head\n'
+b'updating to a closed head\n'
 )
 % currentbranch
 )
 if otherheads:
 ui.warn(
 _(
-"(committing will reopen the head, "
+b"(committing will reopen the head, "
-"use 'hg heads .' to see %i other heads)\n"
+b"use 'hg heads .' to see %i other heads)\n"
 )
 % (len(otherheads))
 )
 else:
 ui.warn(
-_('(committing will reopen branch "%s")\n') % currentbranch
+_(b'(committing will reopen branch "%s")\n') % currentbranch
 )
 elif otherheads:
-curhead = repo['.']
+curhead = repo[b'.']
 ui.status(
-_('updated to "%s: %s"\n')
+_(b'updated to "%s: %s"\n')
-% (curhead, curhead.description().split('\n')[0])
+% (curhead, curhead.description().split(b'\n')[0])
 )
 ui.status(
-_('%i other heads for branch "%s"\n')
+_(b'%i other heads for branch "%s"\n')
 % (len(otherheads), currentbranch)
 )
 def statusotherdests(ui, repo):

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43114	8197b395710e