mercurial: comparison mercurial/bookmarks.py

equal deleted inserted replaced

-:2372284d9457
+:687b865b95ad
 # label constants
 # until 3.5, bookmarks.current was the advertised name, not
 # bookmarks.active, so we must use both to avoid breaking old
 # custom styles
-activebookmarklabel = 'bookmarks.active bookmarks.current'
+activebookmarklabel = b'bookmarks.active bookmarks.current'
-BOOKMARKS_IN_STORE_REQUIREMENT = 'bookmarksinstore'
+BOOKMARKS_IN_STORE_REQUIREMENT = b'bookmarksinstore'
 def bookmarksinstore(repo):
 return BOOKMARKS_IN_STORE_REQUIREMENT in repo.requirements
 For core, this just handles wether we should see pending
 bookmarks or the committed ones. Other extensions (like share)
 may need to tweak this behavior further.
 """
-fp, pending = txnutil.trypending(repo.root, bookmarksvfs(repo), 'bookmarks')
+fp, pending = txnutil.trypending(
+repo.root, bookmarksvfs(repo), b'bookmarks'
+)
 return fp
 class bmstore(object):
 r"""Storage for bookmarks.
 for line in bkfile:
 line = line.strip()
 if not line:
 continue
 try:
-sha, refspec = line.split(' ', 1)
+sha, refspec = line.split(b' ', 1)
 node = tonode(sha)
 if node in nm:
 refspec = encoding.tolocal(refspec)
 refmap[refspec] = node
 nrefs = nodemap.get(node)
 # TypeError:
 # - bin(...)
 # ValueError:
 # - node in nm, for non-20-bytes entry
 # - split(...), for string without ' '
-bookmarkspath = '.hg/bookmarks'
+bookmarkspath = b'.hg/bookmarks'
 if bookmarksinstore(repo):
-bookmarkspath = '.hg/store/bookmarks'
+bookmarkspath = b'.hg/store/bookmarks'
 repo.ui.warn(
-_('malformed line in %s: %r\n')
+_(b'malformed line in %s: %r\n')
 % (bookmarkspath, pycompat.bytestr(line))
 )
 except IOError as inst:
 if inst.errno != errno.ENOENT:
 raise
 return self._active
 @active.setter
 def active(self, mark):
 if mark is not None and mark not in self._refmap:
-raise AssertionError('bookmark %s does not exist!' % mark)
+raise AssertionError(b'bookmark %s does not exist!' % mark)
 self._active = mark
 self._aclean = False
 def __len__(self):
 return self._nodemap.get(node, [])
 def applychanges(self, repo, tr, changes):
 """Apply a list of changes to bookmarks
 """
-bmchanges = tr.changes.get('bookmarks')
+bmchanges = tr.changes.get(b'bookmarks')
 for name, node in changes:
 old = self._refmap.get(name)
 if node is None:
 self._del(name)
 else:
 def _recordchange(self, tr):
 """record that bookmarks have been changed in a transaction
 The transaction is then responsible for updating the file content."""
-location = '' if bookmarksinstore(self._repo) else 'plain'
+location = b'' if bookmarksinstore(self._repo) else b'plain'
 tr.addfilegenerator(
-'bookmarks', ('bookmarks',), self._write, location=location
+b'bookmarks', (b'bookmarks',), self._write, location=location
 )
-tr.hookargs['bookmark_moved'] = '1'
+tr.hookargs[b'bookmark_moved'] = b'1'
 def _writerepo(self, repo):
 """Factored out for extensibility"""
 rbm = repo._bookmarks
 if rbm.active not in self._refmap:
 lock = repo.lock()
 else:
 vfs = repo.vfs
 lock = repo.wlock()
 with lock:
-with vfs('bookmarks', 'w', atomictemp=True, checkambig=True) as f:
+with vfs(b'bookmarks', b'w', atomictemp=True, checkambig=True) as f:
 self._write(f)
 def _writeactive(self):
 if self._aclean:
 return
 with self._repo.wlock():
 if self._active is not None:
 with self._repo.vfs(
-'bookmarks.current', 'w', atomictemp=True, checkambig=True
+b'bookmarks.current', b'w', atomictemp=True, checkambig=True
 ) as f:
 f.write(encoding.fromlocal(self._active))
 else:
-self._repo.vfs.tryunlink('bookmarks.current')
+self._repo.vfs.tryunlink(b'bookmarks.current')
 self._aclean = True
 def _write(self, fp):
 for name, node in sorted(self._refmap.iteritems()):
-fp.write("%s %s\n" % (hex(node), encoding.fromlocal(name)))
+fp.write(b"%s %s\n" % (hex(node), encoding.fromlocal(name)))
 self._clean = True
 self._repo.invalidatevolatilesets()
 def expandname(self, bname):
-if bname == '.':
+if bname == b'.':
 if self.active:
 return self.active
 else:
-raise error.RepoLookupError(_("no active bookmark"))
+raise error.RepoLookupError(_(b"no active bookmark"))
 return bname
 def checkconflict(self, mark, force=False, target=None):
 """check repo for a potential clash of mark with an existing bookmark,
 branch, or hash
 If force is supplied, then forcibly move the bookmark to a new commit
 regardless if it is a move forward.
 If divergent bookmark are to be deleted, they will be returned as list.
 """
-cur = self._repo['.'].node()
+cur = self._repo[b'.'].node()
 if mark in self._refmap and not force:
 if target:
 if self._refmap[mark] == target and target == cur:
 # re-activating a bookmark
 return []
 anc = self._repo.changelog.ancestors([rev])
 bmctx = self._repo[self[mark]]
 divs = [
 self._refmap[b]
 for b in self._refmap
-if b.split('@', 1)[0] == mark.split('@', 1)[0]
+if b.split(b'@', 1)[0] == mark.split(b'@', 1)[0]
 ]
 # allow resolving a single divergent bookmark even if moving
 # the bookmark across branches when a revision is specified
 # that contains a divergent bookmark
 b for b in divs if self._repo[b].rev() in anc or b == target
 ]
 delbms = divergent2delete(self._repo, deletefrom, mark)
 if validdest(self._repo, bmctx, self._repo[target]):
 self._repo.ui.status(
-_("moving bookmark '%s' forward from %s\n")
+_(b"moving bookmark '%s' forward from %s\n")
 % (mark, short(bmctx.node()))
 )
 return delbms
 raise error.Abort(
-_("bookmark '%s' already exists " "(use -f to force)") % mark
+_(b"bookmark '%s' already exists " b"(use -f to force)") % mark
 )
 if (
 mark in self._repo.branchmap()
 or mark == self._repo.dirstate.branch()
 ) and not force:
 raise error.Abort(
-_("a bookmark cannot have the name of an existing branch")
+_(b"a bookmark cannot have the name of an existing branch")
 )
 if len(mark) > 3 and not force:
 try:
 shadowhash = scmutil.isrevsymbol(self._repo, mark)
 except error.LookupError:  # ambiguous identifier
 shadowhash = False
 if shadowhash:
 self._repo.ui.warn(
 _(
-"bookmark %s matches a changeset hash\n"
+b"bookmark %s matches a changeset hash\n"
-"(did you leave a -r out of an 'hg bookmark' "
+b"(did you leave a -r out of an 'hg bookmark' "
-"command?)\n"
+b"command?)\n"
 )
 % mark
 )
 return []
 itself as we commit. This function returns the name of that bookmark.
 It is stored in .hg/bookmarks.current
 """
 # No readline() in osutil.posixfile, reading everything is
 # cheap.
-content = repo.vfs.tryread('bookmarks.current')
+content = repo.vfs.tryread(b'bookmarks.current')
-mark = encoding.tolocal((content.splitlines() or [''])[0])
+mark = encoding.tolocal((content.splitlines() or [b''])[0])
-if mark == '' or mark not in marks:
+if mark == b'' or mark not in marks:
 mark = None
 return mark
 def activate(repo, mark):
 """find divergent versions of bm on nodes in deletefrom.
 the list of bookmark to delete."""
 todelete = []
 marks = repo._bookmarks
-divergent = [b for b in marks if b.split('@', 1)[0] == bm.split('@', 1)[0]]
+divergent = [
+b for b in marks if b.split(b'@', 1)[0] == bm.split(b'@', 1)[0]
+]
 for mark in divergent:
-if mark == '@' or '@' not in mark:
+if mark == b'@' or b'@' not in mark:
 # can't be divergent by definition
 continue
 if mark and marks[mark] in deletefrom:
 if mark != bm:
 todelete.append(mark)
 there were no divergent bookmarks, then this list will contain
 only one entry.
 """
 if not repo._activebookmark:
 raise ValueError(
-'headsforactive() only makes sense with an active bookmark'
+b'headsforactive() only makes sense with an active bookmark'
 )
-name = repo._activebookmark.split('@', 1)[0]
+name = repo._activebookmark.split(b'@', 1)[0]
 heads = []
 for mark, n in repo._bookmarks.iteritems():
-if mark.split('@', 1)[0] == name:
+if mark.split(b'@', 1)[0] == name:
 heads.append(n)
 return heads
 def calculateupdate(ui, repo):
 '''Return a tuple (activemark, movemarkfrom) indicating the active bookmark
 and where to move the active bookmark from, if needed.'''
 checkout, movemarkfrom = None, None
 activemark = repo._activebookmark
 if isactivewdirparent(repo):
-movemarkfrom = repo['.'].node()
+movemarkfrom = repo[b'.'].node()
 elif activemark:
-ui.status(_("updating to active bookmark %s\n") % activemark)
+ui.status(_(b"updating to active bookmark %s\n") % activemark)
 checkout = activemark
 return (checkout, movemarkfrom)
 def update(repo, parents, node):
 if marks[active] in parents:
 new = repo[node]
 divs = [
 repo[marks[b]]
 for b in marks
-if b.split('@', 1)[0] == active.split('@', 1)[0]
+if b.split(b'@', 1)[0] == active.split(b'@', 1)[0]
 ]
 anc = repo.changelog.ancestors([new.rev()])
 deletefrom = [b.node() for b in divs if b.rev() in anc or b == new]
 if validdest(repo, repo[marks[active]], new):
 bmchanges.append((active, new.node()))
 for bm in divergent2delete(repo, deletefrom, active):
 bmchanges.append((bm, None))
 if bmchanges:
-with repo.lock(), repo.transaction('bookmark') as tr:
+with repo.lock(), repo.transaction(b'bookmark') as tr:
 marks.applychanges(repo, tr, bmchanges)
 return bool(bmchanges)
 def listbinbookmarks(repo):
 marks = getattr(repo, '_bookmarks', {})
 hasnode = repo.changelog.hasnode
 for k, v in marks.iteritems():
 # don't expose local divergent bookmarks
-if hasnode(v) and ('@' not in k or k.endswith('@')):
+if hasnode(v) and (b'@' not in k or k.endswith(b'@')):
 yield k, v
 def listbookmarks(repo):
 d = {}
 def pushbookmark(repo, key, old, new):
 if bookmarksinstore(repo):
 wlock = util.nullcontextmanager()
 else:
 wlock = repo.wlock()
-with wlock, repo.lock(), repo.transaction('bookmarks') as tr:
+with wlock, repo.lock(), repo.transaction(b'bookmarks') as tr:
 marks = repo._bookmarks
-existing = hex(marks.get(key, ''))
+existing = hex(marks.get(key, b''))
 if existing != old and existing != new:
 return False
-if new == '':
+if new == b'':
 changes = [(key, None)]
 else:
 if new not in repo:
 return False
 changes = [(key, repo[new].node())]
 bookmark name.
 This reuses already existing one with "@number" suffix, if it
 refers ``remotenode``.
 '''
-if b == '@':
+if b == b'@':
-b = ''
+b = b''
 # try to use an @pathalias suffix
 # if an @pathalias already exists, we overwrite (update) it
-if path.startswith("file:"):
+if path.startswith(b"file:"):
 path = util.url(path).path
-for p, u in ui.configitems("paths"):
+for p, u in ui.configitems(b"paths"):
-if u.startswith("file:"):
+if u.startswith(b"file:"):
 u = util.url(u).path
 if path == u:
-return '%s@%s' % (b, p)
+return b'%s@%s' % (b, p)
 # assign a unique "@number" suffix newly
 for x in range(1, 100):
-n = '%s@%d' % (b, x)
+n = b'%s@%d' % (b, x)
 if n not in localmarks or localmarks[n] == remotenode:
 return n
 return None
 for name, node in marks.items():
 binremotemarks[name] = bin(node)
 return binremotemarks
-_binaryentry = struct.Struct('>20sH')
+_binaryentry = struct.Struct(b'>20sH')
 def binaryencode(bookmarks):
 """encode a '(bookmark, node)' iterable into a binary stream
 for book, node in bookmarks:
 if not node:  # None or ''
 node = wdirid
 binarydata.append(_binaryentry.pack(node, len(book)))
 binarydata.append(book)
-return ''.join(binarydata)
+return b''.join(binarydata)
 def binarydecode(stream):
 """decode a binary stream into an '(bookmark, node)' iterable
 books = []
 while True:
 entry = stream.read(entrysize)
 if len(entry) < entrysize:
 if entry:
-raise error.Abort(_('bad bookmark stream'))
+raise error.Abort(_(b'bad bookmark stream'))
 break
 node, length = _binaryentry.unpack(entry)
 bookmark = stream.read(length)
 if len(bookmark) < length:
 if entry:
-raise error.Abort(_('bad bookmark stream'))
+raise error.Abort(_(b'bad bookmark stream'))
 if node == wdirid:
 node = None
 books.append((bookmark, node))
 return books
 def updatefromremote(ui, repo, remotemarks, path, trfunc, explicit=()):
-ui.debug("checking for updated bookmarks\n")
+ui.debug(b"checking for updated bookmarks\n")
 localmarks = repo._bookmarks
 (
 addsrc,
 adddst,
 advsrc,
 same,
 ) = comparebookmarks(repo, remotemarks, localmarks)
 status = ui.status
 warn = ui.warn
-if ui.configbool('ui', 'quietbookmarkmove'):
+if ui.configbool(b'ui', b'quietbookmarkmove'):
 status = warn = ui.debug
 explicit = set(explicit)
 changed = []
 for b, scid, dcid in addsrc:
 if scid in repo:  # add remote bookmarks for changes we already have
 changed.append(
-(b, scid, status, _("adding remote bookmark %s\n") % b)
+(b, scid, status, _(b"adding remote bookmark %s\n") % b)
 )
 elif b in explicit:
 explicit.remove(b)
 ui.warn(
-_("remote bookmark %s points to locally missing %s\n")
+_(b"remote bookmark %s points to locally missing %s\n")
 % (b, hex(scid)[:12])
 )
 for b, scid, dcid in advsrc:
-changed.append((b, scid, status, _("updating bookmark %s\n") % b))
+changed.append((b, scid, status, _(b"updating bookmark %s\n") % b))
 # remove normal movement from explicit set
 explicit.difference_update(d[0] for d in changed)
 for b, scid, dcid in diverge:
 if b in explicit:
 explicit.discard(b)
-changed.append((b, scid, status, _("importing bookmark %s\n") % b))
+changed.append((b, scid, status, _(b"importing bookmark %s\n") % b))
 else:
 db = _diverge(ui, b, path, localmarks, scid)
 if db:
 changed.append(
 (
 db,
 scid,
 warn,
-_("divergent bookmark %s stored as %s\n") % (b, db),
+_(b"divergent bookmark %s stored as %s\n") % (b, db),
 )
 )
 else:
 warn(
 _(
-"warning: failed to assign numbered name "
+b"warning: failed to assign numbered name "
-"to divergent bookmark %s\n"
+b"to divergent bookmark %s\n"
 )
 % b
 )
 for b, scid, dcid in adddst + advdst:
 if b in explicit:
 explicit.discard(b)
-changed.append((b, scid, status, _("importing bookmark %s\n") % b))
+changed.append((b, scid, status, _(b"importing bookmark %s\n") % b))
 for b, scid, dcid in differ:
 if b in explicit:
 explicit.remove(b)
 ui.warn(
-_("remote bookmark %s points to locally missing %s\n")
+_(b"remote bookmark %s points to locally missing %s\n")
 % (b, hex(scid)[:12])
 )
 if changed:
 tr = trfunc()
 def incoming(ui, repo, peer):
 '''Show bookmarks incoming from other to repo
 '''
-ui.status(_("searching for changed bookmarks\n"))
+ui.status(_(b"searching for changed bookmarks\n"))
 with peer.commandexecutor() as e:
 remotemarks = unhexlifybookmarks(
-e.callcommand('listkeys', {'namespace': 'bookmarks',}).result()
+e.callcommand(b'listkeys', {b'namespace': b'bookmarks',}).result()
 )
 r = comparebookmarks(repo, remotemarks, repo._bookmarks)
 addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = r
 else:
 getid = lambda id: id[:12]
 if ui.verbose:
 def add(b, id, st):
-incomings.append("   %-25s %s %s\n" % (b, getid(id), st))
+incomings.append(b"   %-25s %s %s\n" % (b, getid(id), st))
 else:
 def add(b, id, st):
-incomings.append("   %-25s %s\n" % (b, getid(id)))
+incomings.append(b"   %-25s %s\n" % (b, getid(id)))
 for b, scid, dcid in addsrc:
 # i18n: "added" refers to a bookmark
-add(b, hex(scid), _('added'))
+add(b, hex(scid), _(b'added'))
 for b, scid, dcid in advsrc:
 # i18n: "advanced" refers to a bookmark
-add(b, hex(scid), _('advanced'))
+add(b, hex(scid), _(b'advanced'))
 for b, scid, dcid in diverge:
 # i18n: "diverged" refers to a bookmark
-add(b, hex(scid), _('diverged'))
+add(b, hex(scid), _(b'diverged'))
 for b, scid, dcid in differ:
 # i18n: "changed" refers to a bookmark
-add(b, hex(scid), _('changed'))
+add(b, hex(scid), _(b'changed'))
 if not incomings:
-ui.status(_("no changed bookmarks found\n"))
+ui.status(_(b"no changed bookmarks found\n"))
 return 1
 for s in sorted(incomings):
 ui.write(s)
 def outgoing(ui, repo, other):
 '''Show bookmarks outgoing from repo to other
 '''
-ui.status(_("searching for changed bookmarks\n"))
+ui.status(_(b"searching for changed bookmarks\n"))
-remotemarks = unhexlifybookmarks(other.listkeys('bookmarks'))
+remotemarks = unhexlifybookmarks(other.listkeys(b'bookmarks'))
 r = comparebookmarks(repo, repo._bookmarks, remotemarks)
 addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = r
 outgoings = []
 if ui.debugflag:
 else:
 getid = lambda id: id[:12]
 if ui.verbose:
 def add(b, id, st):
-outgoings.append("   %-25s %s %s\n" % (b, getid(id), st))
+outgoings.append(b"   %-25s %s %s\n" % (b, getid(id), st))
 else:
 def add(b, id, st):
-outgoings.append("   %-25s %s\n" % (b, getid(id)))
+outgoings.append(b"   %-25s %s\n" % (b, getid(id)))
 for b, scid, dcid in addsrc:
 # i18n: "added refers to a bookmark
-add(b, hex(scid), _('added'))
+add(b, hex(scid), _(b'added'))
 for b, scid, dcid in adddst:
 # i18n: "deleted" refers to a bookmark
-add(b, ' ' * 40, _('deleted'))
+add(b, b' ' * 40, _(b'deleted'))
 for b, scid, dcid in advsrc:
 # i18n: "advanced" refers to a bookmark
-add(b, hex(scid), _('advanced'))
+add(b, hex(scid), _(b'advanced'))
 for b, scid, dcid in diverge:
 # i18n: "diverged" refers to a bookmark
-add(b, hex(scid), _('diverged'))
+add(b, hex(scid), _(b'diverged'))
 for b, scid, dcid in differ:
 # i18n: "changed" refers to a bookmark
-add(b, hex(scid), _('changed'))
+add(b, hex(scid), _(b'changed'))
 if not outgoings:
-ui.status(_("no changed bookmarks found\n"))
+ui.status(_(b"no changed bookmarks found\n"))
 return 1
 for s in sorted(outgoings):
 ui.write(s)
 This returns "(# of incoming, # of outgoing)" tuple.
 '''
 with peer.commandexecutor() as e:
 remotemarks = unhexlifybookmarks(
-e.callcommand('listkeys', {'namespace': 'bookmarks',}).result()
+e.callcommand(b'listkeys', {b'namespace': b'bookmarks',}).result()
 )
 r = comparebookmarks(repo, remotemarks, repo._bookmarks)
 addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = r
 return (len(addsrc), len(adddst))
 Raises an abort error if the bookmark name is not valid.
 """
 mark = mark.strip()
 if not mark:
 raise error.Abort(
-_("bookmark names cannot consist entirely of " "whitespace")
+_(b"bookmark names cannot consist entirely of " b"whitespace")
 )
-scmutil.checknewlabel(repo, mark, 'bookmark')
+scmutil.checknewlabel(repo, mark, b'bookmark')
 return mark
 def delete(repo, tr, names):
 """remove a mark from the bookmark store
 """
 marks = repo._bookmarks
 changes = []
 for mark in names:
 if mark not in marks:
-raise error.Abort(_("bookmark '%s' does not exist") % mark)
+raise error.Abort(_(b"bookmark '%s' does not exist") % mark)
 if mark == repo._activebookmark:
 deactivate(repo)
 changes.append((mark, None))
 marks.applychanges(repo, tr, changes)
 Raises an abort error if old is not in the bookmark store.
 """
 marks = repo._bookmarks
 mark = checkformat(repo, new)
 if old not in marks:
-raise error.Abort(_("bookmark '%s' does not exist") % old)
+raise error.Abort(_(b"bookmark '%s' does not exist") % old)
 changes = []
 for bm in marks.checkconflict(mark, force):
 changes.append((bm, None))
 changes.extend([(mark, marks[old]), (old, None)])
 marks.applychanges(repo, tr, changes)
 first bookmark is activated.
 Raises an abort error if old is not in the bookmark store.
 """
 marks = repo._bookmarks
-cur = repo['.'].node()
+cur = repo[b'.'].node()
 newact = None
 changes = []
 hiddenrev = None
 # unhide revs if any
 if rev:
-repo = scmutil.unhidehashlikerevs(repo, [rev], 'nowarn')
+repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn')
 for mark in names:
 mark = checkformat(repo, mark)
 if newact is None:
 newact = mark
 for bm in marks.checkconflict(mark, force, tgt):
 changes.append((bm, None))
 changes.append((mark, tgt))
 if hiddenrev:
-repo.ui.warn(_("bookmarking hidden changeset %s\n") % hiddenrev)
+repo.ui.warn(_(b"bookmarking hidden changeset %s\n") % hiddenrev)
 if ctx.obsolete():
-msg = obsutil._getfilteredreason(repo, "%s" % hiddenrev, ctx)
+msg = obsutil._getfilteredreason(repo, b"%s" % hiddenrev, ctx)
-repo.ui.warn("(%s)\n" % msg)
+repo.ui.warn(b"(%s)\n" % msg)
 marks.applychanges(repo, tr, changes)
 if not inactive and cur == marks[newact] and not rev:
 activate(repo, newact)
 elif cur != tgt and newact == repo._activebookmark:
 Provides a way for extensions to control how bookmarks are printed (e.g.
 prepend or postpend names)
 """
 hexfn = fm.hexfunc
 if len(bmarks) == 0 and fm.isplain():
-ui.status(_("no bookmarks set\n"))
+ui.status(_(b"no bookmarks set\n"))
 for bmark, (n, prefix, label) in sorted(bmarks.iteritems()):
 fm.startitem()
 fm.context(repo=repo)
 if not ui.quiet:
-fm.plain(' %s ' % prefix, label=label)
+fm.plain(b' %s ' % prefix, label=label)
-fm.write('bookmark', '%s', bmark, label=label)
+fm.write(b'bookmark', b'%s', bmark, label=label)
-pad = " " * (25 - encoding.colwidth(bmark))
+pad = b" " * (25 - encoding.colwidth(bmark))
 fm.condwrite(
 not ui.quiet,
-'rev node',
+b'rev node',
-pad + ' %d:%s',
+pad + b' %d:%s',
 repo.changelog.rev(n),
 hexfn(n),
 label=label,
 )
 fm.data(active=(activebookmarklabel in label))
-fm.plain('\n')
+fm.plain(b'\n')
 def printbookmarks(ui, repo, fm, names=None):
 """print bookmarks by the given formatter
 """
 marks = repo._bookmarks
 bmarks = {}
 for bmark in names or marks:
 if bmark not in marks:
-raise error.Abort(_("bookmark '%s' does not exist") % bmark)
+raise error.Abort(_(b"bookmark '%s' does not exist") % bmark)
 active = repo._activebookmark
 if bmark == active:
-prefix, label = '*', activebookmarklabel
+prefix, label = b'*', activebookmarklabel
 else:
-prefix, label = ' ', ''
+prefix, label = b' ', b''
 bmarks[bmark] = (marks[bmark], prefix, label)
 _printbookmarks(ui, repo, fm, bmarks)
 def preparehookargs(name, old, new):
 if new is None:
-new = ''
+new = b''
 if old is None:
-old = ''
+old = b''
-return {'bookmark': name, 'node': hex(new), 'oldnode': hex(old)}
+return {b'bookmark': name, b'node': hex(new), b'oldnode': hex(old)}

changeset 43077	687b865b95ad
parent 43076	2372284d9457
child 43089	c59eb1560c44