| martinvonz | |
| dlax | |
| pulkit |
| hg-reviewers |
This is just removing the b'' prefix (except demandimportpy2), and making sure
it is triple quoted. I skipped the mapping.py module in zope because that's 3rd
party code.
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgdemandimport/demandimportpy2.py (6 lines) | |||
| M | hgext/convert/cvsps.py (4 lines) | |||
| M | hgext/convert/p4.py (6 lines) | |||
| M | hgext/hgk.py (2 lines) | |||
| M | hgext/rebase.py (16 lines) | |||
| M | mercurial/changelog.py (7 lines) | |||
| M | mercurial/color.py (4 lines) | |||
| M | mercurial/context.py (2 lines) | |||
| M | mercurial/crecord.py (55 lines) | |||
| M | mercurial/dispatch.py (2 lines) | |||
| M | mercurial/encoding.py (8 lines) | |||
| M | mercurial/filemerge.py (4 lines) | |||
| M | mercurial/hg.py (2 lines) | |||
| M | mercurial/interfaces/dirstate.py (2 lines) | |||
| M | mercurial/merge.py (2 lines) | |||
| M | mercurial/parser.py (15 lines) | |||
| M | mercurial/patch.py (2 lines) | |||
| M | mercurial/subrepo.py (2 lines) | |||
| M | mercurial/ui.py (3 lines) | |||
| M | mercurial/utils/procutil.py (5 lines) | |||
| M | mercurial/windows.py (2 lines) |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| ef223f247754 | aef7b91dba51 | Matt Harbison | Dec 1 2019, 6:46 PM |
| ignores = ignoreset | ignores = ignoreset | ||||
| def isenabled(): | def isenabled(): | ||||
| return builtins.__import__ == _demandimport | return builtins.__import__ == _demandimport | ||||
| def enable(): | def enable(): | ||||
| "enable global demand-loading of modules" | """enable global demand-loading of modules""" | ||||
| builtins.__import__ = _demandimport | builtins.__import__ = _demandimport | ||||
| def disable(): | def disable(): | ||||
| "disable global demand-loading of modules" | """disable global demand-loading of modules""" | ||||
| builtins.__import__ = _origimport | builtins.__import__ = _origimport | ||||
| @contextmanager | @contextmanager | ||||
| def deactivated(): | def deactivated(): | ||||
| "context manager for disabling demandimport in 'with' blocks" | """context manager for disabling demandimport in 'with' blocks""" | ||||
| demandenabled = isenabled() | demandenabled = isenabled() | ||||
| if demandenabled: | if demandenabled: | ||||
| disable() | disable() | ||||
| try: | try: | ||||
| yield | yield | ||||
| finally: | finally: | ||||
| if demandenabled: | if demandenabled: | ||||
| enable() | enable() | ||||
| def createlog(ui, directory=None, root=b"", rlog=True, cache=None): | def createlog(ui, directory=None, root=b"", rlog=True, cache=None): | ||||
| '''Collect the CVS rlog''' | '''Collect the CVS rlog''' | ||||
| # Because we store many duplicate commit log messages, reusing strings | # Because we store many duplicate commit log messages, reusing strings | ||||
| # saves a lot of memory and pickle storage space. | # saves a lot of memory and pickle storage space. | ||||
| _scache = {} | _scache = {} | ||||
| def scache(s): | def scache(s): | ||||
| b"return a shared version of a string" | """return a shared version of a string""" | ||||
| return _scache.setdefault(s, s) | return _scache.setdefault(s, s) | ||||
| ui.status(_(b'collecting CVS rlog\n')) | ui.status(_(b'collecting CVS rlog\n')) | ||||
| log = [] # list of logentry objects containing the CVS state | log = [] # list of logentry objects containing the CVS state | ||||
| # patterns to match in CVS (r)log output, by state of use | # patterns to match in CVS (r)log output, by state of use | ||||
| re_00 = re.compile(b'RCS file: (.+)$') | re_00 = re.compile(b'RCS file: (.+)$') | ||||
| # "File file4 was added on branch ..." (synthetic, 1 entry) | # "File file4 was added on branch ..." (synthetic, 1 entry) | ||||
| # "Add file3 and file4 to fix ..." (real, 2 entries) | # "Add file3 and file4 to fix ..." (real, 2 entries) | ||||
| # Hence the check for 1 entry here. | # Hence the check for 1 entry here. | ||||
| c.synthetic = len(c.entries) == 1 and c.entries[0].synthetic | c.synthetic = len(c.entries) == 1 and c.entries[0].synthetic | ||||
| # Sort files in each changeset | # Sort files in each changeset | ||||
| def entitycompare(l, r): | def entitycompare(l, r): | ||||
| b'Mimic cvsps sorting order' | """Mimic cvsps sorting order""" | ||||
| l = l.file.split(b'/') | l = l.file.split(b'/') | ||||
| r = r.file.split(b'/') | r = r.file.split(b'/') | ||||
| nl = len(l) | nl = len(l) | ||||
| nr = len(r) | nr = len(r) | ||||
| n = min(nl, nr) | n = min(nl, nr) | ||||
| for i in range(n): | for i in range(n): | ||||
| if i + 1 == nl and nl < nr: | if i + 1 == nl and nl < nr: | ||||
| return -1 | return -1 | ||||
| procutil, | procutil, | ||||
| stringutil, | stringutil, | ||||
| ) | ) | ||||
| from . import common | from . import common | ||||
| def loaditer(f): | def loaditer(f): | ||||
| b"Yield the dictionary objects generated by p4" | """Yield the dictionary objects generated by p4""" | ||||
| try: | try: | ||||
| while True: | while True: | ||||
| d = marshal.load(f) | d = marshal.load(f) | ||||
| if not d: | if not d: | ||||
| break | break | ||||
| yield d | yield d | ||||
| except EOFError: | except EOFError: | ||||
| pass | pass | ||||
| Revisions in the map are considered beeing present in the | Revisions in the map are considered beeing present in the | ||||
| repository and ignored during _parse(). This allows for incremental | repository and ignored during _parse(). This allows for incremental | ||||
| imports if a revmap is provided. | imports if a revmap is provided. | ||||
| """ | """ | ||||
| self.revmap = revmap | self.revmap = revmap | ||||
| def _parse_view(self, path): | def _parse_view(self, path): | ||||
| b"Read changes affecting the path" | """Read changes affecting the path""" | ||||
| cmd = b'p4 -G changes -s submitted %s' % procutil.shellquote(path) | cmd = b'p4 -G changes -s submitted %s' % procutil.shellquote(path) | ||||
| stdout = procutil.popen(cmd, mode=b'rb') | stdout = procutil.popen(cmd, mode=b'rb') | ||||
| p4changes = {} | p4changes = {} | ||||
| for d in loaditer(stdout): | for d in loaditer(stdout): | ||||
| c = d.get(b"change", None) | c = d.get(b"change", None) | ||||
| if c: | if c: | ||||
| p4changes[c] = True | p4changes[c] = True | ||||
| return p4changes | return p4changes | ||||
| def _parse(self, ui, path): | def _parse(self, ui, path): | ||||
| b"Prepare list of P4 filenames and revisions to import" | """Prepare list of P4 filenames and revisions to import""" | ||||
| p4changes = {} | p4changes = {} | ||||
| changeset = {} | changeset = {} | ||||
| files_map = {} | files_map = {} | ||||
| copies_map = {} | copies_map = {} | ||||
| localname = {} | localname = {} | ||||
| depotname = {} | depotname = {} | ||||
| heads = [] | heads = [] | ||||
| @command( | @command( | ||||
| b'view', | b'view', | ||||
| [(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM'))], | [(b'l', b'limit', b'', _(b'limit number of changes displayed'), _(b'NUM'))], | ||||
| _(b'[-l LIMIT] [REVRANGE]'), | _(b'[-l LIMIT] [REVRANGE]'), | ||||
| helpcategory=command.CATEGORY_CHANGE_NAVIGATION, | helpcategory=command.CATEGORY_CHANGE_NAVIGATION, | ||||
| ) | ) | ||||
| def view(ui, repo, *etc, **opts): | def view(ui, repo, *etc, **opts): | ||||
| b"start interactive history viewer" | """start interactive history viewer""" | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| os.chdir(repo.root) | os.chdir(repo.root) | ||||
| optstr = b' '.join( | optstr = b' '.join( | ||||
| [b'--%s %s' % (k, v) for k, v in pycompat.iteritems(opts) if v] | [b'--%s %s' % (k, v) for k, v in pycompat.iteritems(opts) if v] | ||||
| ) | ) | ||||
| if repo.filtername is None: | if repo.filtername is None: | ||||
| optstr += b'--hidden' | optstr += b'--hidden' | ||||
| cmd = ui.config(b"hgk", b"path") + b" %s %s" % (optstr, b" ".join(etc)) | cmd = ui.config(b"hgk", b"path") + b" %s %s" % (optstr, b" ".join(etc)) | ||||
| ui.debug(b"running %s\n" % cmd) | ui.debug(b"running %s\n" % cmd) | ||||
| ui.system(cmd, blockedtag=b'hgk_view') | ui.system(cmd, blockedtag=b'hgk_view') | ||||
| text=commitmsg, user=user, date=date, extra=extra, editor=editor | text=commitmsg, user=user, date=date, extra=extra, editor=editor | ||||
| ) | ) | ||||
| repo.dirstate.setbranch(repo[newnode].branch()) | repo.dirstate.setbranch(repo[newnode].branch()) | ||||
| return newnode | return newnode | ||||
| def rebasenode(repo, rev, p1, base, collapse, dest, wctx): | def rebasenode(repo, rev, p1, base, collapse, dest, wctx): | ||||
| b'Rebase a single revision rev on top of p1 using base as merge ancestor' | """Rebase a single revision rev on top of p1 using base as merge ancestor""" | ||||
| # Merge phase | # Merge phase | ||||
| # Update to destination and merge it with local | # Update to destination and merge it with local | ||||
| if wctx.isinmemory(): | if wctx.isinmemory(): | ||||
| wctx.setbase(repo[p1]) | wctx.setbase(repo[p1]) | ||||
| else: | else: | ||||
| if repo[b'.'].rev() != p1: | if repo[b'.'].rev() != p1: | ||||
| repo.ui.debug(b" update to %d:%s\n" % (p1, repo[p1])) | repo.ui.debug(b" update to %d:%s\n" % (p1, repo[p1])) | ||||
| mergemod.update(repo, p1, branchmerge=False, force=True) | mergemod.update(repo, p1, branchmerge=False, force=True) | ||||
| ) | ) | ||||
| repo.ui.debug(b" future parents are %d and %d\n" % tuple(newps)) | repo.ui.debug(b" future parents are %d and %d\n" % tuple(newps)) | ||||
| return newps[0], newps[1], base | return newps[0], newps[1], base | ||||
| def isagitpatch(repo, patchname): | def isagitpatch(repo, patchname): | ||||
| b'Return true if the given patch is in git format' | """Return true if the given patch is in git format""" | ||||
| mqpatch = os.path.join(repo.mq.path, patchname) | mqpatch = os.path.join(repo.mq.path, patchname) | ||||
| for line in patch.linereader(open(mqpatch, b'rb')): | for line in patch.linereader(open(mqpatch, b'rb')): | ||||
| if line.startswith(b'diff --git'): | if line.startswith(b'diff --git'): | ||||
| return True | return True | ||||
| return False | return False | ||||
| def updatemq(repo, state, skipped, **opts): | def updatemq(repo, state, skipped, **opts): | ||||
| b'Update rebased mq patches - finalize and then import them' | """Update rebased mq patches - finalize and then import them""" | ||||
| mqrebase = {} | mqrebase = {} | ||||
| mq = repo.mq | mq = repo.mq | ||||
| original_series = mq.fullseries[:] | original_series = mq.fullseries[:] | ||||
| skippedpatches = set() | skippedpatches = set() | ||||
| for p in mq.applied: | for p in mq.applied: | ||||
| rev = repo[p.node].rev() | rev = repo[p.node].rev() | ||||
| if rev in state: | if rev in state: | ||||
| if mq.guard_re.split(s, 1)[0] not in skippedpatches | if mq.guard_re.split(s, 1)[0] not in skippedpatches | ||||
| ] | ] | ||||
| mq.fullseries[:] = newseries | mq.fullseries[:] = newseries | ||||
| mq.seriesdirty = True | mq.seriesdirty = True | ||||
| mq.savedirty() | mq.savedirty() | ||||
| def storecollapsemsg(repo, collapsemsg): | def storecollapsemsg(repo, collapsemsg): | ||||
| b'Store the collapse message to allow recovery' | """Store the collapse message to allow recovery""" | ||||
| collapsemsg = collapsemsg or b'' | collapsemsg = collapsemsg or b'' | ||||
| f = repo.vfs(b"last-message.txt", b"w") | f = repo.vfs(b"last-message.txt", b"w") | ||||
| f.write(b"%s\n" % collapsemsg) | f.write(b"%s\n" % collapsemsg) | ||||
| f.close() | f.close() | ||||
| def clearcollapsemsg(repo): | def clearcollapsemsg(repo): | ||||
| b'Remove collapse message file' | """Remove collapse message file""" | ||||
| repo.vfs.unlinkpath(b"last-message.txt", ignoremissing=True) | repo.vfs.unlinkpath(b"last-message.txt", ignoremissing=True) | ||||
| def restorecollapsemsg(repo, isabort): | def restorecollapsemsg(repo, isabort): | ||||
| b'Restore previously stored collapse message' | """Restore previously stored collapse message""" | ||||
| try: | try: | ||||
| f = repo.vfs(b"last-message.txt") | f = repo.vfs(b"last-message.txt") | ||||
| collapsemsg = f.readline().strip() | collapsemsg = f.readline().strip() | ||||
| f.close() | f.close() | ||||
| except IOError as err: | except IOError as err: | ||||
| if err.errno != errno.ENOENT: | if err.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| if isabort: | if isabort: | ||||
| # Oh well, just abort like normal | # Oh well, just abort like normal | ||||
| collapsemsg = b'' | collapsemsg = b'' | ||||
| else: | else: | ||||
| raise error.Abort(_(b'missing .hg/last-message.txt for rebase')) | raise error.Abort(_(b'missing .hg/last-message.txt for rebase')) | ||||
| return collapsemsg | return collapsemsg | ||||
| def clearstatus(repo): | def clearstatus(repo): | ||||
| b'Remove the status files' | """Remove the status files""" | ||||
| # Make sure the active transaction won't write the state file | # Make sure the active transaction won't write the state file | ||||
| tr = repo.currenttransaction() | tr = repo.currenttransaction() | ||||
| if tr: | if tr: | ||||
| tr.removefilegenerator(b'rebasestate') | tr.removefilegenerator(b'rebasestate') | ||||
| repo.vfs.unlinkpath(b"rebasestate", ignoremissing=True) | repo.vfs.unlinkpath(b"rebasestate", ignoremissing=True) | ||||
| def needupdate(repo, state): | def needupdate(repo, state): | ||||
| nodechanges = fd(changes, key=b"oldnode", value=b"newnodes") | nodechanges = fd(changes, key=b"oldnode", value=b"newnodes") | ||||
| fm.data(nodechanges=nodechanges) | fm.data(nodechanges=nodechanges) | ||||
| if keepf: | if keepf: | ||||
| replacements = {} | replacements = {} | ||||
| scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup) | scmutil.cleanupnodes(repo, replacements, b'rebase', moves, backup=backup) | ||||
| def pullrebase(orig, ui, repo, *args, **opts): | def pullrebase(orig, ui, repo, *args, **opts): | ||||
| b'Call rebase after pull if the latter has been invoked with --rebase' | """Call rebase after pull if the latter has been invoked with --rebase""" | ||||
| if opts.get('rebase'): | if opts.get('rebase'): | ||||
| if ui.configbool(b'commands', b'rebase.requiredest'): | if ui.configbool(b'commands', b'rebase.requiredest'): | ||||
| msg = _(b'rebase destination required by configuration') | msg = _(b'rebase destination required by configuration') | ||||
| hint = _(b'use hg pull followed by hg rebase -d DEST') | hint = _(b'use hg pull followed by hg rebase -d DEST') | ||||
| raise error.Abort(msg, hint=hint) | raise error.Abort(msg, hint=hint) | ||||
| with repo.wlock(), repo.lock(): | with repo.wlock(), repo.lock(): | ||||
| if opts.get('update'): | if opts.get('update'): | ||||
| self._realopener = opener | self._realopener = opener | ||||
| self._delayed = False | self._delayed = False | ||||
| self._delaybuf = None | self._delaybuf = None | ||||
| self._divert = False | self._divert = False | ||||
| self.filteredrevs = frozenset() | self.filteredrevs = frozenset() | ||||
| self._copiesstorage = opener.options.get(b'copies-storage') | self._copiesstorage = opener.options.get(b'copies-storage') | ||||
| def delayupdate(self, tr): | def delayupdate(self, tr): | ||||
| b"delay visibility of index updates to other readers" | """delay visibility of index updates to other readers""" | ||||
| if not self._delayed: | if not self._delayed: | ||||
| if len(self) == 0: | if len(self) == 0: | ||||
| self._divert = True | self._divert = True | ||||
| if self._realopener.exists(self.indexfile + b'.a'): | if self._realopener.exists(self.indexfile + b'.a'): | ||||
| self._realopener.unlink(self.indexfile + b'.a') | self._realopener.unlink(self.indexfile + b'.a') | ||||
| self.opener = _divertopener(self._realopener, self.indexfile) | self.opener = _divertopener(self._realopener, self.indexfile) | ||||
| else: | else: | ||||
| self._delaybuf = [] | self._delaybuf = [] | ||||
| self.opener = _delayopener( | self.opener = _delayopener( | ||||
| self._realopener, self.indexfile, self._delaybuf | self._realopener, self.indexfile, self._delaybuf | ||||
| ) | ) | ||||
| self._delayed = True | self._delayed = True | ||||
| tr.addpending(b'cl-%i' % id(self), self._writepending) | tr.addpending(b'cl-%i' % id(self), self._writepending) | ||||
| tr.addfinalize(b'cl-%i' % id(self), self._finalize) | tr.addfinalize(b'cl-%i' % id(self), self._finalize) | ||||
| def _finalize(self, tr): | def _finalize(self, tr): | ||||
| b"finalize index updates" | """finalize index updates""" | ||||
| self._delayed = False | self._delayed = False | ||||
| self.opener = self._realopener | self.opener = self._realopener | ||||
| # move redirected index data back into place | # move redirected index data back into place | ||||
| if self._divert: | if self._divert: | ||||
| assert not self._delaybuf | assert not self._delaybuf | ||||
| tmpname = self.indexfile + b".a" | tmpname = self.indexfile + b".a" | ||||
| nfile = self.opener.open(tmpname) | nfile = self.opener.open(tmpname) | ||||
| nfile.close() | nfile.close() | ||||
| self.opener.rename(tmpname, self.indexfile, checkambig=True) | self.opener.rename(tmpname, self.indexfile, checkambig=True) | ||||
| elif self._delaybuf: | elif self._delaybuf: | ||||
| fp = self.opener(self.indexfile, b'a', checkambig=True) | fp = self.opener(self.indexfile, b'a', checkambig=True) | ||||
| fp.write(b"".join(self._delaybuf)) | fp.write(b"".join(self._delaybuf)) | ||||
| fp.close() | fp.close() | ||||
| self._delaybuf = None | self._delaybuf = None | ||||
| self._divert = False | self._divert = False | ||||
| # split when we're done | # split when we're done | ||||
| self._enforceinlinesize(tr) | self._enforceinlinesize(tr) | ||||
| def _writepending(self, tr): | def _writepending(self, tr): | ||||
| b"create a file containing the unfinalized state for pretxnchangegroup" | """create a file containing the unfinalized state for | ||||
| pretxnchangegroup""" | |||||
| if self._delaybuf: | if self._delaybuf: | ||||
| # make a temporary copy of the index | # make a temporary copy of the index | ||||
| fp1 = self._realopener(self.indexfile) | fp1 = self._realopener(self.indexfile) | ||||
| pendingfilename = self.indexfile + b".a" | pendingfilename = self.indexfile + b".a" | ||||
| # register as a temp file to ensure cleanup on failure | # register as a temp file to ensure cleanup on failure | ||||
| tr.registertmp(pendingfilename) | tr.registertmp(pendingfilename) | ||||
| # write existing data | # write existing data | ||||
| fp2 = self._realopener(pendingfilename, b"w") | fp2 = self._realopener(pendingfilename, b"w") | ||||
| if ui._colormode == b'win32': | if ui._colormode == b'win32': | ||||
| return w32effects | return w32effects | ||||
| elif ui._colormode is not None: | elif ui._colormode is not None: | ||||
| return _effects | return _effects | ||||
| return {} | return {} | ||||
| def valideffect(ui, effect): | def valideffect(ui, effect): | ||||
| b'Determine if the effect is valid or not.' | """Determine if the effect is valid or not.""" | ||||
| return (not ui._terminfoparams and effect in _activeeffects(ui)) or ( | return (not ui._terminfoparams and effect in _activeeffects(ui)) or ( | ||||
| effect in ui._terminfoparams or effect[:-11] in ui._terminfoparams | effect in ui._terminfoparams or effect[:-11] in ui._terminfoparams | ||||
| ) | ) | ||||
| def _effect_str(ui, effect): | def _effect_str(ui, effect): | ||||
| '''Helper function for render_effects().''' | '''Helper function for render_effects().''' | ||||
| for t in text.split(stop): | for t in text.split(stop): | ||||
| if not t: | if not t: | ||||
| continue | continue | ||||
| parts.extend([start, t, stop]) | parts.extend([start, t, stop]) | ||||
| return b''.join(parts) | return b''.join(parts) | ||||
| def _render_effects(ui, text, effects): | def _render_effects(ui, text, effects): | ||||
| b'Wrap text in commands to turn on each effect.' | """Wrap text in commands to turn on each effect.""" | ||||
| if not text: | if not text: | ||||
| return text | return text | ||||
| if ui._terminfoparams: | if ui._terminfoparams: | ||||
| start = b''.join( | start = b''.join( | ||||
| _effect_str(ui, effect) for effect in [b'none'] + effects.split() | _effect_str(ui, effect) for effect in [b'none'] + effects.split() | ||||
| ) | ) | ||||
| stop = _effect_str(ui, b'none') | stop = _effect_str(ui, b'none') | ||||
| else: | else: | ||||
| def filectx(self, path, filelog=None): | def filectx(self, path, filelog=None): | ||||
| """get a file context from the working directory""" | """get a file context from the working directory""" | ||||
| return workingfilectx( | return workingfilectx( | ||||
| self._repo, path, workingctx=self, filelog=filelog | self._repo, path, workingctx=self, filelog=filelog | ||||
| ) | ) | ||||
| def dirty(self, missing=False, merge=True, branch=True): | def dirty(self, missing=False, merge=True, branch=True): | ||||
| b"check whether a working directory is modified" | """check whether a working directory is modified""" | ||||
| # check subrepos first | # check subrepos first | ||||
| for s in sorted(self.substate): | for s in sorted(self.substate): | ||||
| if self.sub(s).dirty(missing=missing): | if self.sub(s).dirty(missing=missing): | ||||
| return True | return True | ||||
| # check current working dir | # check current working dir | ||||
| return ( | return ( | ||||
| (merge and self.p2()) | (merge and self.p2()) | ||||
| or (branch and self.branch() != self.p1().branch()) | or (branch and self.branch() != self.p1().branch()) | ||||
| def firstchild(self): | def firstchild(self): | ||||
| raise NotImplementedError(b"method must be implemented by subclass") | raise NotImplementedError(b"method must be implemented by subclass") | ||||
| def lastchild(self): | def lastchild(self): | ||||
| raise NotImplementedError(b"method must be implemented by subclass") | raise NotImplementedError(b"method must be implemented by subclass") | ||||
| def allchildren(self): | def allchildren(self): | ||||
| b"Return a list of all of the direct children of this node" | """Return a list of all of the direct children of this node""" | ||||
| raise NotImplementedError(b"method must be implemented by subclass") | raise NotImplementedError(b"method must be implemented by subclass") | ||||
| def nextsibling(self): | def nextsibling(self): | ||||
| """ | """ | ||||
| Return the closest next item of the same type where there are no items | Return the closest next item of the same type where there are no items | ||||
| of different types between the current item and this closest item. | of different types between the current item and this closest item. | ||||
| If no such item exists, return None. | If no such item exists, return None. | ||||
| """ | """ | ||||
| def parentitem(self): | def parentitem(self): | ||||
| """ | """ | ||||
| there is no 'real' parent item of a header that can be selected, | there is no 'real' parent item of a header that can be selected, | ||||
| so return None. | so return None. | ||||
| """ | """ | ||||
| return None | return None | ||||
| def firstchild(self): | def firstchild(self): | ||||
| b"return the first child of this item, if one exists. otherwise None." | """return the first child of this item, if one exists. otherwise | ||||
| None.""" | |||||
| if len(self.hunks) > 0: | if len(self.hunks) > 0: | ||||
| return self.hunks[0] | return self.hunks[0] | ||||
| else: | else: | ||||
| return None | return None | ||||
| def lastchild(self): | def lastchild(self): | ||||
| b"return the last child of this item, if one exists. otherwise None." | """return the last child of this item, if one exists. otherwise | ||||
| None.""" | |||||
| if len(self.hunks) > 0: | if len(self.hunks) > 0: | ||||
| return self.hunks[-1] | return self.hunks[-1] | ||||
| else: | else: | ||||
| return None | return None | ||||
| def allchildren(self): | def allchildren(self): | ||||
| b"return a list of all of the direct children of this node" | """return a list of all of the direct children of this node""" | ||||
| return self.hunks | return self.hunks | ||||
| def __getattr__(self, name): | def __getattr__(self, name): | ||||
| return getattr(self.nonuiheader, name) | return getattr(self.nonuiheader, name) | ||||
| class uihunkline(patchnode): | class uihunkline(patchnode): | ||||
| b"represents a changed line in a hunk" | """represents a changed line in a hunk""" | ||||
| def __init__(self, linetext, hunk): | def __init__(self, linetext, hunk): | ||||
| self.linetext = linetext | self.linetext = linetext | ||||
| self.applied = True | self.applied = True | ||||
| # the parent hunk to which this line belongs | # the parent hunk to which this line belongs | ||||
| self.hunk = hunk | self.hunk = hunk | ||||
| # folding lines currently is not used/needed, but this flag is needed | # folding lines currently is not used/needed, but this flag is needed | ||||
| # in the previtem method. | # in the previtem method. | ||||
| indexofthisline = self.hunk.changedlines.index(self) | indexofthisline = self.hunk.changedlines.index(self) | ||||
| if indexofthisline > 0: | if indexofthisline > 0: | ||||
| previousline = self.hunk.changedlines[indexofthisline - 1] | previousline = self.hunk.changedlines[indexofthisline - 1] | ||||
| return previousline | return previousline | ||||
| else: | else: | ||||
| return None | return None | ||||
| def parentitem(self): | def parentitem(self): | ||||
| b"return the parent to the current item" | """return the parent to the current item""" | ||||
| return self.hunk | return self.hunk | ||||
| def firstchild(self): | def firstchild(self): | ||||
| b"return the first child of this item, if one exists. otherwise None." | """return the first child of this item, if one exists. otherwise | ||||
| None.""" | |||||
| # hunk-lines don't have children | # hunk-lines don't have children | ||||
| return None | return None | ||||
| def lastchild(self): | def lastchild(self): | ||||
| b"return the last child of this item, if one exists. otherwise None." | """return the last child of this item, if one exists. otherwise | ||||
| None.""" | |||||
| # hunk-lines don't have children | # hunk-lines don't have children | ||||
| return None | return None | ||||
| class uihunk(patchnode): | class uihunk(patchnode): | ||||
| """ui patch hunk, wraps a hunk and keep track of ui behavior """ | """ui patch hunk, wraps a hunk and keep track of ui behavior """ | ||||
| maxcontext = 3 | maxcontext = 3 | ||||
| indexofthishunk = self.header.hunks.index(self) | indexofthishunk = self.header.hunks.index(self) | ||||
| if indexofthishunk > 0: | if indexofthishunk > 0: | ||||
| previoushunk = self.header.hunks[indexofthishunk - 1] | previoushunk = self.header.hunks[indexofthishunk - 1] | ||||
| return previoushunk | return previoushunk | ||||
| else: | else: | ||||
| return None | return None | ||||
| def parentitem(self): | def parentitem(self): | ||||
| b"return the parent to the current item" | """return the parent to the current item""" | ||||
| return self.header | return self.header | ||||
| def firstchild(self): | def firstchild(self): | ||||
| b"return the first child of this item, if one exists. otherwise None." | """return the first child of this item, if one exists. otherwise | ||||
| None.""" | |||||
| if len(self.changedlines) > 0: | if len(self.changedlines) > 0: | ||||
| return self.changedlines[0] | return self.changedlines[0] | ||||
| else: | else: | ||||
| return None | return None | ||||
| def lastchild(self): | def lastchild(self): | ||||
| b"return the last child of this item, if one exists. otherwise None." | """return the last child of this item, if one exists. otherwise | ||||
| None.""" | |||||
| if len(self.changedlines) > 0: | if len(self.changedlines) > 0: | ||||
| return self.changedlines[-1] | return self.changedlines[-1] | ||||
| else: | else: | ||||
| return None | return None | ||||
| def allchildren(self): | def allchildren(self): | ||||
| b"return a list of all of the direct children of this node" | """return a list of all of the direct children of this node""" | ||||
| return self.changedlines | return self.changedlines | ||||
| def countchanges(self): | def countchanges(self): | ||||
| """changedlines -> (n+,n-)""" | """changedlines -> (n+,n-)""" | ||||
| add = len( | add = len( | ||||
| [ | [ | ||||
| l | l | ||||
| for l in self.changedlines | for l in self.changedlines | ||||
| if nextitem is None: | if nextitem is None: | ||||
| break | break | ||||
| else: | else: | ||||
| currentitem = nextitem | currentitem = nextitem | ||||
| self.currentselecteditem = currentitem | self.currentselecteditem = currentitem | ||||
| def updatescroll(self): | def updatescroll(self): | ||||
| b"scroll the screen to fully show the currently-selected" | """scroll the screen to fully show the currently-selected""" | ||||
| selstart = self.selecteditemstartline | selstart = self.selecteditemstartline | ||||
| selend = self.selecteditemendline | selend = self.selecteditemendline | ||||
| padstart = self.firstlineofpadtoprint | padstart = self.firstlineofpadtoprint | ||||
| padend = padstart + self.yscreensize - self.numstatuslines - 1 | padend = padstart + self.yscreensize - self.numstatuslines - 1 | ||||
| # 'buffered' pad start/end values which scroll with a certain | # 'buffered' pad start/end values which scroll with a certain | ||||
| # top/bottom context margin | # top/bottom context margin | ||||
| padstartbuffered = padstart + 3 | padstartbuffered = padstart + 3 | ||||
| padendbuffered = padend - 3 | padendbuffered = padend - 3 | ||||
| if selend > padendbuffered: | if selend > padendbuffered: | ||||
| self.scrolllines(selend - padendbuffered) | self.scrolllines(selend - padendbuffered) | ||||
| elif selstart < padstartbuffered: | elif selstart < padstartbuffered: | ||||
| # negative values scroll in pgup direction | # negative values scroll in pgup direction | ||||
| self.scrolllines(selstart - padstartbuffered) | self.scrolllines(selstart - padstartbuffered) | ||||
| def scrolllines(self, numlines): | def scrolllines(self, numlines): | ||||
| b"scroll the screen up (down) by numlines when numlines >0 (<0)." | """scroll the screen up (down) by numlines when numlines >0 (<0).""" | ||||
| self.firstlineofpadtoprint += numlines | self.firstlineofpadtoprint += numlines | ||||
| if self.firstlineofpadtoprint < 0: | if self.firstlineofpadtoprint < 0: | ||||
| self.firstlineofpadtoprint = 0 | self.firstlineofpadtoprint = 0 | ||||
| if self.firstlineofpadtoprint > self.numpadlines - 1: | if self.firstlineofpadtoprint > self.numpadlines - 1: | ||||
| self.firstlineofpadtoprint = self.numpadlines - 1 | self.firstlineofpadtoprint = self.numpadlines - 1 | ||||
| def toggleapply(self, item=None): | def toggleapply(self, item=None): | ||||
| """ | """ | ||||
| # set the applied and partial status of the header if needed | # set the applied and partial status of the header if needed | ||||
| else: # some/all parent siblings are applied | else: # some/all parent siblings are applied | ||||
| item.hunk.header.applied = True | item.hunk.header.applied = True | ||||
| item.hunk.header.partial = ( | item.hunk.header.partial = ( | ||||
| someparentsiblingspartial or not allparentsiblingsapplied | someparentsiblingspartial or not allparentsiblingsapplied | ||||
| ) | ) | ||||
| def toggleall(self): | def toggleall(self): | ||||
| b"toggle the applied flag of all items." | """toggle the applied flag of all items.""" | ||||
| if self.waslasttoggleallapplied: # then unapply them this time | if self.waslasttoggleallapplied: # then unapply them this time | ||||
| for item in self.headerlist: | for item in self.headerlist: | ||||
| if item.applied: | if item.applied: | ||||
| self.toggleapply(item) | self.toggleapply(item) | ||||
| else: | else: | ||||
| for item in self.headerlist: | for item in self.headerlist: | ||||
| if not item.applied: | if not item.applied: | ||||
| self.toggleapply(item) | self.toggleapply(item) | ||||
| self.waslasttoggleallapplied = not self.waslasttoggleallapplied | self.waslasttoggleallapplied = not self.waslasttoggleallapplied | ||||
| def toggleallbetween(self): | def toggleallbetween(self): | ||||
| b"toggle applied on or off for all items in range [lastapplied,current]." | """toggle applied on or off for all items in range [lastapplied, | ||||
| current]. """ | |||||
| if ( | if ( | ||||
| not self.lastapplieditem | not self.lastapplieditem | ||||
| or self.currentselecteditem == self.lastapplieditem | or self.currentselecteditem == self.lastapplieditem | ||||
| ): | ): | ||||
| # Treat this like a normal 'x'/' ' | # Treat this like a normal 'x'/' ' | ||||
| self.toggleapply() | self.toggleapply() | ||||
| return | return | ||||
| # This does *not* invert each item (i.e. middleitem stays marked/on) | # This does *not* invert each item (i.e. middleitem stays marked/on) | ||||
| desiredstate = not self.currentselecteditem.applied | desiredstate = not self.currentselecteditem.applied | ||||
| while nextitem != enditem.nextitem(): | while nextitem != enditem.nextitem(): | ||||
| if nextitem.applied != desiredstate: | if nextitem.applied != desiredstate: | ||||
| self.toggleapply(item=nextitem) | self.toggleapply(item=nextitem) | ||||
| nextitem = nextitem.nextitem() | nextitem = nextitem.nextitem() | ||||
| def togglefolded(self, item=None, foldparent=False): | def togglefolded(self, item=None, foldparent=False): | ||||
| b"toggle folded flag of specified item (defaults to currently selected)" | """toggle folded flag of specified item (defaults to currently | ||||
| selected)""" | |||||
| if item is None: | if item is None: | ||||
| item = self.currentselecteditem | item = self.currentselecteditem | ||||
| if foldparent or (isinstance(item, uiheader) and item.neverunfolded): | if foldparent or (isinstance(item, uiheader) and item.neverunfolded): | ||||
| if not isinstance(item, uiheader): | if not isinstance(item, uiheader): | ||||
| # we need to select the parent item in this case | # we need to select the parent item in this case | ||||
| self.currentselecteditem = item = item.parentitem() | self.currentselecteditem = item = item.parentitem() | ||||
| elif item.neverunfolded: | elif item.neverunfolded: | ||||
| item.neverunfolded = False | item.neverunfolded = False | ||||
| self.chunkpad, linestr, pair=colorpair, towin=towin | self.chunkpad, linestr, pair=colorpair, towin=towin | ||||
| ) | ) | ||||
| return outstr | return outstr | ||||
| def printhunklinesbefore( | def printhunklinesbefore( | ||||
| self, hunk, selected=False, towin=True, ignorefolding=False | self, hunk, selected=False, towin=True, ignorefolding=False | ||||
| ): | ): | ||||
| b"includes start/end line indicator" | """includes start/end line indicator""" | ||||
| outstr = b"" | outstr = b"" | ||||
| # where hunk is in list of siblings | # where hunk is in list of siblings | ||||
| hunkindex = hunk.header.hunks.index(hunk) | hunkindex = hunk.header.hunks.index(hunk) | ||||
| if hunkindex != 0: | if hunkindex != 0: | ||||
| # add separating line before headers | # add separating line before headers | ||||
| outstr += self.printstring( | outstr += self.printstring( | ||||
| self.chunkpad, b' ' * self.xscreensize, towin=towin, align=False | self.chunkpad, b' ' * self.xscreensize, towin=towin, align=False | ||||
| # temporarily disable printing to windows by printstring | # temporarily disable printing to windows by printstring | ||||
| patchdisplaystring = self.printitem( | patchdisplaystring = self.printitem( | ||||
| item, ignorefolding, recursechildren, towin=False | item, ignorefolding, recursechildren, towin=False | ||||
| ) | ) | ||||
| numlines = len(patchdisplaystring) // self.xscreensize | numlines = len(patchdisplaystring) // self.xscreensize | ||||
| return numlines | return numlines | ||||
| def sigwinchhandler(self, n, frame): | def sigwinchhandler(self, n, frame): | ||||
| b"handle window resizing" | """handle window resizing""" | ||||
| try: | try: | ||||
| curses.endwin() | curses.endwin() | ||||
| self.xscreensize, self.yscreensize = scmutil.termsize(self.ui) | self.xscreensize, self.yscreensize = scmutil.termsize(self.ui) | ||||
| self.statuswin.resize(self.numstatuslines, self.xscreensize) | self.statuswin.resize(self.numstatuslines, self.xscreensize) | ||||
| self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1 | self.numpadlines = self.getnumlinesdisplayed(ignorefolding=True) + 1 | ||||
| self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize) | self.chunkpad = curses.newpad(self.numpadlines, self.xscreensize) | ||||
| except curses.error: | except curses.error: | ||||
| pass | pass | ||||
| else: | else: | ||||
| # just apply a select few (safe?) attributes | # just apply a select few (safe?) attributes | ||||
| for textattrib in (curses.A_UNDERLINE, curses.A_BOLD): | for textattrib in (curses.A_UNDERLINE, curses.A_BOLD): | ||||
| if textattrib in attrlist: | if textattrib in attrlist: | ||||
| colorpair |= textattrib | colorpair |= textattrib | ||||
| return colorpair | return colorpair | ||||
| def initcolorpair(self, *args, **kwargs): | def initcolorpair(self, *args, **kwargs): | ||||
| b"same as getcolorpair." | """same as getcolorpair.""" | ||||
| self.getcolorpair(*args, **kwargs) | self.getcolorpair(*args, **kwargs) | ||||
| def helpwindow(self): | def helpwindow(self): | ||||
| b"print a help window to the screen. exit after any keypress." | """print a help window to the screen. exit after any keypress.""" | ||||
| helptext = _( | helptext = _( | ||||
| """ [press any key to return to the patch-display] | """ [press any key to return to the patch-display] | ||||
| crecord allows you to interactively choose among the changes you have made, | crecord allows you to interactively choose among the changes you have made, | ||||
| and confirm only those changes you select for further processing by the command | and confirm only those changes you select for further processing by the command | ||||
| you are running (commit/shelve/revert), after confirming the selected | you are running (commit/shelve/revert), after confirming the selected | ||||
| changes, the unselected changes are still present in your working copy, so you | changes, the unselected changes are still present in your working copy, so you | ||||
| can use crecord multiple times to split large changes into smaller changesets. | can use crecord multiple times to split large changes into smaller changesets. | ||||
| helpwin.refresh() | helpwin.refresh() | ||||
| try: | try: | ||||
| with self.ui.timeblockedsection(b'crecord'): | with self.ui.timeblockedsection(b'crecord'): | ||||
| helpwin.getkey() | helpwin.getkey() | ||||
| except curses.error: | except curses.error: | ||||
| pass | pass | ||||
| def commitMessageWindow(self): | def commitMessageWindow(self): | ||||
| b"Create a temporary commit message editing window on the screen." | """Create a temporary commit message editing window on the screen.""" | ||||
| curses.raw() | curses.raw() | ||||
| curses.def_prog_mode() | curses.def_prog_mode() | ||||
| curses.endwin() | curses.endwin() | ||||
| self.commenttext = self.ui.edit(self.commenttext, self.ui.username()) | self.commenttext = self.ui.edit(self.commenttext, self.ui.username()) | ||||
| curses.cbreak() | curses.cbreak() | ||||
| self.stdscr.refresh() | self.stdscr.refresh() | ||||
| self.stdscr.keypad(1) # allow arrow-keys to continue to function | self.stdscr.keypad(1) # allow arrow-keys to continue to function | ||||
| break | break | ||||
| else: | else: | ||||
| currentitem = nextitem | currentitem = nextitem | ||||
| self.currentselecteditem = currentitem | self.currentselecteditem = currentitem | ||||
| self.recenterdisplayedarea() | self.recenterdisplayedarea() | ||||
| def confirmationwindow(self, windowtext): | def confirmationwindow(self, windowtext): | ||||
| b"display an informational window, then wait for and return a keypress." | """display an informational window, then wait for and return a | ||||
| keypress.""" | |||||
| confirmwin = curses.newwin(self.yscreensize, 0, 0, 0) | confirmwin = curses.newwin(self.yscreensize, 0, 0, 0) | ||||
| try: | try: | ||||
| lines = windowtext.split(b"\n") | lines = windowtext.split(b"\n") | ||||
| for line in lines: | for line in lines: | ||||
| self.printstring(confirmwin, line, pairname=b"selected") | self.printstring(confirmwin, line, pairname=b"selected") | ||||
| except curses.error: | except curses.error: | ||||
| pass | pass | ||||
| self.ui.warnnoi18n(b'error in exit handlers:\n') | self.ui.warnnoi18n(b'error in exit handlers:\n') | ||||
| self.ui.traceback(force=True) | self.ui.traceback(force=True) | ||||
| finally: | finally: | ||||
| if exc is not None: | if exc is not None: | ||||
| raise exc | raise exc | ||||
| def run(): | def run(): | ||||
| b"run the command in sys.argv" | """run the command in sys.argv""" | ||||
| initstdio() | initstdio() | ||||
| with tracing.log('parse args into request'): | with tracing.log('parse args into request'): | ||||
| req = request(pycompat.sysargv[1:]) | req = request(pycompat.sysargv[1:]) | ||||
| err = None | err = None | ||||
| try: | try: | ||||
| status = dispatch(req) | status = dispatch(req) | ||||
| except error.StdioError as e: | except error.StdioError as e: | ||||
| err = e | err = e | ||||
| environ.get(b"HGENCODINGAMBIGUOUS", b"narrow") == b"wide" | environ.get(b"HGENCODINGAMBIGUOUS", b"narrow") == b"wide" | ||||
| and b"WFA" | and b"WFA" | ||||
| or b"WF" | or b"WF" | ||||
| ) | ) | ||||
| def colwidth(s): | def colwidth(s): | ||||
| # type: (bytes) -> int | # type: (bytes) -> int | ||||
| b"Find the column width of a string for display in the local encoding" | """Find the column width of a string for display in the local encoding""" | ||||
| return ucolwidth(s.decode(_sysstr(encoding), 'replace')) | return ucolwidth(s.decode(_sysstr(encoding), 'replace')) | ||||
| def ucolwidth(d): | def ucolwidth(d): | ||||
| # type: (Text) -> int | # type: (Text) -> int | ||||
| b"Find the column width of a Unicode string for display" | """Find the column width of a Unicode string for display""" | ||||
| eaw = getattr(unicodedata, 'east_asian_width', None) | eaw = getattr(unicodedata, 'east_asian_width', None) | ||||
| if eaw is not None: | if eaw is not None: | ||||
| return sum([eaw(c) in _wide and 2 or 1 for c in d]) | return sum([eaw(c) in _wide and 2 or 1 for c in d]) | ||||
| return len(d) | return len(d) | ||||
| def getcols(s, start, c): | def getcols(s, start, c): | ||||
| # type: (bytes, int, int) -> bytes | # type: (bytes, int, int) -> bytes | ||||
| usub = uslice(i) | usub = uslice(i) | ||||
| if ucolwidth(usub) <= width: | if ucolwidth(usub) <= width: | ||||
| return concat(usub.encode(_sysstr(encoding))) | return concat(usub.encode(_sysstr(encoding))) | ||||
| return ellipsis # no enough room for multi-column characters | return ellipsis # no enough room for multi-column characters | ||||
| def lower(s): | def lower(s): | ||||
| # type: (bytes) -> bytes | # type: (bytes) -> bytes | ||||
| b"best-effort encoding-aware case-folding of local string s" | """best-effort encoding-aware case-folding of local string s""" | ||||
| try: | try: | ||||
| return asciilower(s) | return asciilower(s) | ||||
| except UnicodeDecodeError: | except UnicodeDecodeError: | ||||
| pass | pass | ||||
| try: | try: | ||||
| if isinstance(s, localstr): | if isinstance(s, localstr): | ||||
| u = s._utf8.decode("utf-8") | u = s._utf8.decode("utf-8") | ||||
| else: | else: | ||||
| u = s.decode(_sysstr(encoding), _sysstr(encodingmode)) | u = s.decode(_sysstr(encoding), _sysstr(encodingmode)) | ||||
| lu = u.lower() | lu = u.lower() | ||||
| if u == lu: | if u == lu: | ||||
| return s # preserve localstring | return s # preserve localstring | ||||
| return lu.encode(_sysstr(encoding)) | return lu.encode(_sysstr(encoding)) | ||||
| except UnicodeError: | except UnicodeError: | ||||
| return s.lower() # we don't know how to fold this except in ASCII | return s.lower() # we don't know how to fold this except in ASCII | ||||
| except LookupError as k: | except LookupError as k: | ||||
| raise error.Abort(k, hint=b"please check your locale settings") | raise error.Abort(k, hint=b"please check your locale settings") | ||||
| def upper(s): | def upper(s): | ||||
| # type: (bytes) -> bytes | # type: (bytes) -> bytes | ||||
| b"best-effort encoding-aware case-folding of local string s" | """best-effort encoding-aware case-folding of local string s""" | ||||
| try: | try: | ||||
| return asciiupper(s) | return asciiupper(s) | ||||
| except UnicodeDecodeError: | except UnicodeDecodeError: | ||||
| return upperfallback(s) | return upperfallback(s) | ||||
| def upperfallback(s): | def upperfallback(s): | ||||
| # type: (Any) -> Any | # type: (Any) -> Any | ||||
| if not changedelete and len(tools): | if not changedelete and len(tools): | ||||
| # any tool is rejected by capability for symlink or binary | # any tool is rejected by capability for symlink or binary | ||||
| ui.warn(_(b"no tool found to merge %s\n") % path) | ui.warn(_(b"no tool found to merge %s\n") % path) | ||||
| return b":prompt", None | return b":prompt", None | ||||
| return b":merge", None | return b":merge", None | ||||
| def _eoltype(data): | def _eoltype(data): | ||||
| b"Guess the EOL type of a file" | """Guess the EOL type of a file""" | ||||
| if b'\0' in data: # binary | if b'\0' in data: # binary | ||||
| return None | return None | ||||
| if b'\r\n' in data: # Windows | if b'\r\n' in data: # Windows | ||||
| return b'\r\n' | return b'\r\n' | ||||
| if b'\r' in data: # Old Mac | if b'\r' in data: # Old Mac | ||||
| return b'\r' | return b'\r' | ||||
| if b'\n' in data: # UNIX | if b'\n' in data: # UNIX | ||||
| return b'\n' | return b'\n' | ||||
| return None # unknown | return None # unknown | ||||
| def _matcheol(file, back): | def _matcheol(file, back): | ||||
| b"Convert EOL markers in a file to match origfile" | """Convert EOL markers in a file to match origfile""" | ||||
| tostyle = _eoltype(back.data()) # No repo.wread filters? | tostyle = _eoltype(back.data()) # No repo.wread filters? | ||||
| if tostyle: | if tostyle: | ||||
| data = util.readfile(file) | data = util.readfile(file) | ||||
| style = _eoltype(data) | style = _eoltype(data) | ||||
| if style: | if style: | ||||
| newdata = data.replace(style, tostyle) | newdata = data.replace(style, tostyle) | ||||
| if newdata != data: | if newdata != data: | ||||
| util.writefile(file, newdata) | util.writefile(file, newdata) | ||||
| _(b'.hgsubstate is corrupt in revision %s\n') | _(b'.hgsubstate is corrupt in revision %s\n') | ||||
| % node.short(ctx.node()) | % node.short(ctx.node()) | ||||
| ) | ) | ||||
| return ret | return ret | ||||
| def remoteui(src, opts): | def remoteui(src, opts): | ||||
| b'build a remote ui from ui or repo and opts' | """build a remote ui from ui or repo and opts""" | ||||
| if util.safehasattr(src, b'baseui'): # looks like a repository | if util.safehasattr(src, b'baseui'): # looks like a repository | ||||
| dst = src.baseui.copy() # drop repo-specific config | dst = src.baseui.copy() # drop repo-specific config | ||||
| src = src.ui # copy target options from repo | src = src.ui # copy target options from repo | ||||
| else: # assume it's a global ui object | else: # assume it's a global ui object | ||||
| dst = src.copy() # keep all global options | dst = src.copy() # keep all global options | ||||
| # copy ssh-specific options | # copy ssh-specific options | ||||
| for o in b'ssh', b'remotecmd': | for o in b'ssh', b'remotecmd': | ||||
| # TODO: all these private methods and attributes should be made | # TODO: all these private methods and attributes should be made | ||||
| # public or removed from the interface. | # public or removed from the interface. | ||||
| _ignore = interfaceutil.Attribute("""Matcher for ignored files.""") | _ignore = interfaceutil.Attribute("""Matcher for ignored files.""") | ||||
| def _ignorefiles(): | def _ignorefiles(): | ||||
| """Return a list of files containing patterns to ignore.""" | """Return a list of files containing patterns to ignore.""" | ||||
| def _ignorefileandline(f): | def _ignorefileandline(f): | ||||
| b"Given a file `f`, return the ignore file and line that ignores it." | """Given a file `f`, return the ignore file and line that ignores it.""" | ||||
| _checklink = interfaceutil.Attribute("""Callable for checking symlinks.""") | _checklink = interfaceutil.Attribute("""Callable for checking symlinks.""") | ||||
| _checkexec = interfaceutil.Attribute("""Callable for checking exec bits.""") | _checkexec = interfaceutil.Attribute("""Callable for checking exec bits.""") | ||||
| @contextlib.contextmanager | @contextlib.contextmanager | ||||
| def parentchange(): | def parentchange(): | ||||
| '''Context manager for handling dirstate parents. | '''Context manager for handling dirstate parents. | ||||
| ] | ] | ||||
| progress.complete() | progress.complete() | ||||
| assert len(getfiledata) == (len(actions[ACTION_GET]) if wantfiledata else 0) | assert len(getfiledata) == (len(actions[ACTION_GET]) if wantfiledata else 0) | ||||
| return updateresult(updated, merged, removed, unresolved), getfiledata | return updateresult(updated, merged, removed, unresolved), getfiledata | ||||
| def recordupdates(repo, actions, branchmerge, getfiledata): | def recordupdates(repo, actions, branchmerge, getfiledata): | ||||
| b"record merge actions to the dirstate" | """record merge actions to the dirstate""" | ||||
| # remove (must come first) | # remove (must come first) | ||||
| for f, args, msg in actions.get(ACTION_REMOVE, []): | for f, args, msg in actions.get(ACTION_REMOVE, []): | ||||
| if branchmerge: | if branchmerge: | ||||
| repo.dirstate.remove(f) | repo.dirstate.remove(f) | ||||
| else: | else: | ||||
| repo.dirstate.drop(f) | repo.dirstate.drop(f) | ||||
| # forget (must come first) | # forget (must come first) | ||||
| class parser(object): | class parser(object): | ||||
| def __init__(self, elements, methods=None): | def __init__(self, elements, methods=None): | ||||
| self._elements = elements | self._elements = elements | ||||
| self._methods = methods | self._methods = methods | ||||
| self.current = None | self.current = None | ||||
| def _advance(self): | def _advance(self): | ||||
| b'advance the tokenizer' | """advance the tokenizer""" | ||||
| t = self.current | t = self.current | ||||
| self.current = next(self._iter, None) | self.current = next(self._iter, None) | ||||
| return t | return t | ||||
| def _hasnewterm(self): | def _hasnewterm(self): | ||||
| b'True if next token may start new term' | """True if next token may start new term""" | ||||
| return any(self._elements[self.current[0]][1:3]) | return any(self._elements[self.current[0]][1:3]) | ||||
| def _match(self, m): | def _match(self, m): | ||||
| b'make sure the tokenizer matches an end condition' | """make sure the tokenizer matches an end condition""" | ||||
| if self.current[0] != m: | if self.current[0] != m: | ||||
| raise error.ParseError( | raise error.ParseError( | ||||
| _(b"unexpected token: %s") % self.current[0], self.current[2] | _(b"unexpected token: %s") % self.current[0], self.current[2] | ||||
| ) | ) | ||||
| self._advance() | self._advance() | ||||
| def _parseoperand(self, bind, m=None): | def _parseoperand(self, bind, m=None): | ||||
| b'gather right-hand-side operand until an end condition or binding met' | """gather right-hand-side operand until an end condition or binding | ||||
| met""" | |||||
| if m and self.current[0] == m: | if m and self.current[0] == m: | ||||
| expr = None | expr = None | ||||
| else: | else: | ||||
| expr = self._parse(bind) | expr = self._parse(bind) | ||||
| if m: | if m: | ||||
| self._match(m) | self._match(m) | ||||
| return expr | return expr | ||||
| expr = (suffix, expr) | expr = (suffix, expr) | ||||
| elif infix: | elif infix: | ||||
| expr = (infix[0], expr, self._parseoperand(*infix[1:])) | expr = (infix[0], expr, self._parseoperand(*infix[1:])) | ||||
| else: | else: | ||||
| raise error.ParseError(_(b"not an infix: %s") % token, pos) | raise error.ParseError(_(b"not an infix: %s") % token, pos) | ||||
| return expr | return expr | ||||
| def parse(self, tokeniter): | def parse(self, tokeniter): | ||||
| b'generate a parse tree from tokens' | """generate a parse tree from tokens""" | ||||
| self._iter = tokeniter | self._iter = tokeniter | ||||
| self._advance() | self._advance() | ||||
| res = self._parse() | res = self._parse() | ||||
| token, value, pos = self.current | token, value, pos = self.current | ||||
| return res, pos | return res, pos | ||||
| def eval(self, tree): | def eval(self, tree): | ||||
| b'recursively evaluate a parse tree using node methods' | """recursively evaluate a parse tree using node methods""" | ||||
| if not isinstance(tree, tuple): | if not isinstance(tree, tuple): | ||||
| return tree | return tree | ||||
| return self._methods[tree[0]](*[self.eval(t) for t in tree[1:]]) | return self._methods[tree[0]](*[self.eval(t) for t in tree[1:]]) | ||||
| def __call__(self, tokeniter): | def __call__(self, tokeniter): | ||||
| b'parse tokens into a parse tree and evaluate if methods given' | """parse tokens into a parse tree and evaluate if methods given""" | ||||
| t = self.parse(tokeniter) | t = self.parse(tokeniter) | ||||
| if self._methods: | if self._methods: | ||||
| return self.eval(t) | return self.eval(t) | ||||
| return t | return t | ||||
| def splitargspec(spec): | def splitargspec(spec): | ||||
| """Parse spec of function arguments into (poskeys, varkey, keys, optkey) | """Parse spec of function arguments into (poskeys, varkey, keys, optkey) | ||||
| if self.lena and oldstart > 0: | if self.lena and oldstart > 0: | ||||
| oldstart -= 1 | oldstart -= 1 | ||||
| if self.lenb and newstart > 0: | if self.lenb and newstart > 0: | ||||
| newstart -= 1 | newstart -= 1 | ||||
| return old, oldstart, new, newstart | return old, oldstart, new, newstart | ||||
| class binhunk(object): | class binhunk(object): | ||||
| b'A binary patch file.' | """A binary patch file.""" | ||||
| def __init__(self, lr, fname): | def __init__(self, lr, fname): | ||||
| self.text = None | self.text = None | ||||
| self.delta = False | self.delta = False | ||||
| self.hunk = [b'GIT binary patch\n'] | self.hunk = [b'GIT binary patch\n'] | ||||
| self._fname = fname | self._fname = fname | ||||
| self._read(lr) | self._read(lr) | ||||
| continue | continue | ||||
| if ref.startswith(b'refs/remotes/') and ref.endswith(b'/HEAD'): | if ref.startswith(b'refs/remotes/') and ref.endswith(b'/HEAD'): | ||||
| continue # ignore remote/HEAD redirects | continue # ignore remote/HEAD redirects | ||||
| branch2rev[ref] = revision | branch2rev[ref] = revision | ||||
| rev2branch.setdefault(revision, []).append(ref) | rev2branch.setdefault(revision, []).append(ref) | ||||
| return branch2rev, rev2branch | return branch2rev, rev2branch | ||||
| def _gittracking(self, branches): | def _gittracking(self, branches): | ||||
| b'return map of remote branch to local tracking branch' | """return map of remote branch to local tracking branch""" | ||||
| # assumes no more than one local tracking branch for each remote | # assumes no more than one local tracking branch for each remote | ||||
| tracking = {} | tracking = {} | ||||
| for b in branches: | for b in branches: | ||||
| if b.startswith(b'refs/remotes/'): | if b.startswith(b'refs/remotes/'): | ||||
| continue | continue | ||||
| bname = b.split(b'/', 2)[2] | bname = b.split(b'/', 2)[2] | ||||
| remote = self._gitcommand([b'config', b'branch.%s.remote' % bname]) | remote = self._gitcommand([b'config', b'branch.%s.remote' % bname]) | ||||
| if remote: | if remote: | ||||
| self.debug( | self.debug( | ||||
| b'ignoring untrusted configuration option ' | b'ignoring untrusted configuration option ' | ||||
| b'%s:%s.%s = %s\n' % (section, name, k, uvalue) | b'%s:%s.%s = %s\n' % (section, name, k, uvalue) | ||||
| ) | ) | ||||
| return main, sub | return main, sub | ||||
| def configpath(self, section, name, default=_unset, untrusted=False): | def configpath(self, section, name, default=_unset, untrusted=False): | ||||
| b'get a path config item, expanded relative to repo root or config file' | """get a path config item, expanded relative to repo root or config | ||||
| file""" | |||||
| v = self.config(section, name, default, untrusted) | v = self.config(section, name, default, untrusted) | ||||
| if v is None: | if v is None: | ||||
| return None | return None | ||||
| if not os.path.isabs(v) or b"://" not in v: | if not os.path.isabs(v) or b"://" not in v: | ||||
| src = self.configsource(section, name, untrusted) | src = self.configsource(section, name, untrusted) | ||||
| if b':' in src: | if b':' in src: | ||||
| base = os.path.dirname(src.rsplit(b':')[0]) | base = os.path.dirname(src.rsplit(b':')[0]) | ||||
| v = os.path.join(base, os.path.expanduser(v)) | v = os.path.join(base, os.path.expanduser(v)) | ||||
| _filtertable = { | _filtertable = { | ||||
| b'tempfile:': tempfilter, | b'tempfile:': tempfilter, | ||||
| b'pipe:': pipefilter, | b'pipe:': pipefilter, | ||||
| } | } | ||||
| def filter(s, cmd): | def filter(s, cmd): | ||||
| b"filter a string through a command that transforms its input to its output" | """filter a string through a command that transforms its input to its | ||||
| output""" | |||||
| for name, fn in pycompat.iteritems(_filtertable): | for name, fn in pycompat.iteritems(_filtertable): | ||||
| if cmd.startswith(name): | if cmd.startswith(name): | ||||
| return fn(s, cmd[len(name) :].lstrip()) | return fn(s, cmd[len(name) :].lstrip()) | ||||
| return pipefilter(s, cmd) | return pipefilter(s, cmd) | ||||
| _hgexecutable = None | _hgexecutable = None | ||||
| os.dup2(f.fileno(), uif.fileno()) | os.dup2(f.fileno(), uif.fileno()) | ||||
| f.close() | f.close() | ||||
| def shellenviron(environ=None): | def shellenviron(environ=None): | ||||
| """return environ with optional override, useful for shelling out""" | """return environ with optional override, useful for shelling out""" | ||||
| def py2shell(val): | def py2shell(val): | ||||
| b'convert python object into string that is useful to shell' | """convert python object into string that is useful to shell""" | ||||
| if val is None or val is False: | if val is None or val is False: | ||||
| return b'0' | return b'0' | ||||
| if val is True: | if val is True: | ||||
| return b'1' | return b'1' | ||||
| return pycompat.bytestr(val) | return pycompat.bytestr(val) | ||||
| env = dict(encoding.environ) | env = dict(encoding.environ) | ||||
| if environ: | if environ: | ||||
| An extension from PATHEXT is found and added if not present. | An extension from PATHEXT is found and added if not present. | ||||
| If command isn't found None is returned.''' | If command isn't found None is returned.''' | ||||
| pathext = encoding.environ.get(b'PATHEXT', b'.COM;.EXE;.BAT;.CMD') | pathext = encoding.environ.get(b'PATHEXT', b'.COM;.EXE;.BAT;.CMD') | ||||
| pathexts = [ext for ext in pathext.lower().split(pycompat.ospathsep)] | pathexts = [ext for ext in pathext.lower().split(pycompat.ospathsep)] | ||||
| if os.path.splitext(command)[1].lower() in pathexts: | if os.path.splitext(command)[1].lower() in pathexts: | ||||
| pathexts = [b''] | pathexts = [b''] | ||||
| def findexisting(pathcommand): | def findexisting(pathcommand): | ||||
| b'Will append extension (if needed) and return existing file' | """Will append extension (if needed) and return existing file""" | ||||
| for ext in pathexts: | for ext in pathexts: | ||||
| executable = pathcommand + ext | executable = pathcommand + ext | ||||
| if os.path.exists(executable): | if os.path.exists(executable): | ||||
| return executable | return executable | ||||
| return None | return None | ||||
| if pycompat.ossep in command: | if pycompat.ossep in command: | ||||
| return findexisting(command) | return findexisting(command) | ||||