| durin42 | |
| martinvonz | |
| Alphare |
| hg-reviewers |
pycompat.iteritems() just calls .items().
This commit applies a regular expression search and replace to convert
simple instances of pycompat.iteritems() with .items(). There are still
a handful of calls to pycompat.iteritems() remaining. But these all have
more complicated expressions that I wasn't comfortable performing an
automated replace on. In addition, some simple replacements were withheld
because they broke pytype. These will be handled by their own changesets.
| No Linters Available |
| No Unit Test Coverage |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| f1e46ca72c16 | 46b3ecfb16e2 | Gregory Szorc | Mar 1 2022, 11:42 PM |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | D12339 ui: use input() directly | |
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg | ||
| Closed | indygreg |
| fm.data(linetype=b'path') | fm.data(linetype=b'path') | ||||
| fstate.diffwith(targetfctx, fm) | fstate.diffwith(targetfctx, fm) | ||||
| self.fixupmap[path] = fstate | self.fixupmap[path] = fstate | ||||
| self.paths.append(path) | self.paths.append(path) | ||||
| self.ctxaffected.update(fstate.ctxaffected) | self.ctxaffected.update(fstate.ctxaffected) | ||||
| def apply(self): | def apply(self): | ||||
| """apply fixups to individual filefixupstates""" | """apply fixups to individual filefixupstates""" | ||||
| for path, state in pycompat.iteritems(self.fixupmap): | for path, state in self.fixupmap.items(): | ||||
| if self.ui.debugflag: | if self.ui.debugflag: | ||||
| self.ui.write(_(b'applying fixups to %s\n') % path) | self.ui.write(_(b'applying fixups to %s\n') % path) | ||||
| state.apply() | state.apply() | ||||
| @property | @property | ||||
| def chunkstats(self): | def chunkstats(self): | ||||
| """-> {path: chunkstats}. collect chunkstats from filefixupstates""" | """-> {path: chunkstats}. collect chunkstats from filefixupstates""" | ||||
| return { | return {path: state.chunkstats for path, state in self.fixupmap.items()} | ||||
| path: state.chunkstats | |||||
| for path, state in pycompat.iteritems(self.fixupmap) | |||||
| } | |||||
| def commit(self): | def commit(self): | ||||
| """commit changes. update self.finalnode, self.replacemap""" | """commit changes. update self.finalnode, self.replacemap""" | ||||
| with self.repo.transaction(b'absorb') as tr: | with self.repo.transaction(b'absorb') as tr: | ||||
| self._commitstack() | self._commitstack() | ||||
| self._movebookmarks(tr) | self._movebookmarks(tr) | ||||
| if self.repo[b'.'].node() in self.replacemap: | if self.repo[b'.'].node() in self.replacemap: | ||||
| self._moveworkingdirectoryparent() | self._moveworkingdirectoryparent() | ||||
| self._cleanupoldcommits() | self._cleanupoldcommits() | ||||
| return self.finalnode | return self.finalnode | ||||
| def printchunkstats(self): | def printchunkstats(self): | ||||
| """print things like '1 of 2 chunk(s) applied'""" | """print things like '1 of 2 chunk(s) applied'""" | ||||
| ui = self.ui | ui = self.ui | ||||
| chunkstats = self.chunkstats | chunkstats = self.chunkstats | ||||
| if ui.verbose: | if ui.verbose: | ||||
| # chunkstats for each file | # chunkstats for each file | ||||
| for path, stat in pycompat.iteritems(chunkstats): | for path, stat in chunkstats.items(): | ||||
| if stat[0]: | if stat[0]: | ||||
| ui.write( | ui.write( | ||||
| _(b'%s: %d of %d chunk(s) applied\n') | _(b'%s: %d of %d chunk(s) applied\n') | ||||
| % (path, stat[0], stat[1]) | % (path, stat[0], stat[1]) | ||||
| ) | ) | ||||
| elif not ui.quiet: | elif not ui.quiet: | ||||
| # a summary for all files | # a summary for all files | ||||
| stats = chunkstats.values() | stats = chunkstats.values() | ||||
| if content != newcontent: | if content != newcontent: | ||||
| result[fctx.path()] = newcontent | result[fctx.path()] = newcontent | ||||
| return result | return result | ||||
| def _movebookmarks(self, tr): | def _movebookmarks(self, tr): | ||||
| repo = self.repo | repo = self.repo | ||||
| needupdate = [ | needupdate = [ | ||||
| (name, self.replacemap[hsh]) | (name, self.replacemap[hsh]) | ||||
| for name, hsh in pycompat.iteritems(repo._bookmarks) | for name, hsh in repo._bookmarks.items() | ||||
| if hsh in self.replacemap | if hsh in self.replacemap | ||||
| ] | ] | ||||
| changes = [] | changes = [] | ||||
| for name, hsh in needupdate: | for name, hsh in needupdate: | ||||
| if hsh: | if hsh: | ||||
| changes.append((name, hsh)) | changes.append((name, hsh)) | ||||
| if self.ui.verbose: | if self.ui.verbose: | ||||
| self.ui.write( | self.ui.write( | ||||
| pctx = parents[0] | pctx = parents[0] | ||||
| if ctx.branch() != pctx.branch(): | if ctx.branch() != pctx.branch(): | ||||
| return False | return False | ||||
| if ctx.extra().get(b'close'): | if ctx.extra().get(b'close'): | ||||
| return False | return False | ||||
| # ctx changes more files (not a subset of memworkingcopy) | # ctx changes more files (not a subset of memworkingcopy) | ||||
| if not set(ctx.files()).issubset(set(memworkingcopy)): | if not set(ctx.files()).issubset(set(memworkingcopy)): | ||||
| return False | return False | ||||
| for path, content in pycompat.iteritems(memworkingcopy): | for path, content in memworkingcopy.items(): | ||||
| if path not in pctx or path not in ctx: | if path not in pctx or path not in ctx: | ||||
| return False | return False | ||||
| fctx = ctx[path] | fctx = ctx[path] | ||||
| pfctx = pctx[path] | pfctx = pctx[path] | ||||
| if pfctx.flags() != fctx.flags(): | if pfctx.flags() != fctx.flags(): | ||||
| return False | return False | ||||
| if pfctx.data() != content: | if pfctx.data() != content: | ||||
| return False | return False | ||||
| @util.propertycache | @util.propertycache | ||||
| def _useobsolete(self): | def _useobsolete(self): | ||||
| """() -> bool""" | """() -> bool""" | ||||
| return obsolete.isenabled(self.repo, obsolete.createmarkersopt) | return obsolete.isenabled(self.repo, obsolete.createmarkersopt) | ||||
| def _cleanupoldcommits(self): | def _cleanupoldcommits(self): | ||||
| replacements = { | replacements = { | ||||
| k: ([v] if v is not None else []) | k: ([v] if v is not None else []) | ||||
| for k, v in pycompat.iteritems(self.replacemap) | for k, v in self.replacemap.items() | ||||
| } | } | ||||
| if replacements: | if replacements: | ||||
| scmutil.cleanupnodes( | scmutil.cleanupnodes( | ||||
| self.repo, replacements, operation=b'absorb', fixphase=True | self.repo, replacements, operation=b'absorb', fixphase=True | ||||
| ) | ) | ||||
| @util.propertycache | @util.propertycache | ||||
| def skip_empty_successor(self): | def skip_empty_successor(self): | ||||
| # change, no binary diff, and no renames, it's probably okay to | # change, no binary diff, and no renames, it's probably okay to | ||||
| # re-invent the logic using much simpler code here. | # re-invent the logic using much simpler code here. | ||||
| memworkingcopy = {} # {path: content} | memworkingcopy = {} # {path: content} | ||||
| patchmap = defaultdict(lambda: []) # {path: [(a1, a2, [bline])]} | patchmap = defaultdict(lambda: []) # {path: [(a1, a2, [bline])]} | ||||
| for path, info in map(_parsechunk, chunks): | for path, info in map(_parsechunk, chunks): | ||||
| if not path or not info: | if not path or not info: | ||||
| continue | continue | ||||
| patchmap[path].append(info) | patchmap[path].append(info) | ||||
| for path, patches in pycompat.iteritems(patchmap): | for path, patches in patchmap.items(): | ||||
| if path not in ctx or not patches: | if path not in ctx or not patches: | ||||
| continue | continue | ||||
| patches.sort(reverse=True) | patches.sort(reverse=True) | ||||
| lines = mdiff.splitnewlines(ctx[path].data()) | lines = mdiff.splitnewlines(ctx[path].data()) | ||||
| for a1, a2, blines in patches: | for a1, a2, blines in patches: | ||||
| lines[a1:a2] = blines | lines[a1:a2] = blines | ||||
| memworkingcopy[path] = b''.join(lines) | memworkingcopy[path] = b''.join(lines) | ||||
| return overlaycontext(memworkingcopy, ctx) | return overlaycontext(memworkingcopy, ctx) | ||||
| # it cannot access `bar` repositories, but they were never used very much. | # it cannot access `bar` repositories, but they were never used very much. | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial import ( | from mercurial import ( | ||||
| demandimport, | demandimport, | ||||
| error, | error, | ||||
| pycompat, | |||||
| util, | util, | ||||
| ) | ) | ||||
| from . import common | from . import common | ||||
| # these do not work with demandimport, blacklist | # these do not work with demandimport, blacklist | ||||
| demandimport.IGNORES.update( | demandimport.IGNORES.update( | ||||
| [ | [ | ||||
| ) | ) | ||||
| def gettags(self): | def gettags(self): | ||||
| bytetags = {} | bytetags = {} | ||||
| for branch in self._bzrbranches(): | for branch in self._bzrbranches(): | ||||
| if not branch.supports_tags(): | if not branch.supports_tags(): | ||||
| return {} | return {} | ||||
| tagdict = branch.tags.get_tag_dict() | tagdict = branch.tags.get_tag_dict() | ||||
| for name, rev in pycompat.iteritems(tagdict): | for name, rev in tagdict.items(): | ||||
| bytetags[self.recode(name)] = rev | bytetags[self.recode(name)] = rev | ||||
| return bytetags | return bytetags | ||||
| def getchangedfiles(self, rev, i): | def getchangedfiles(self, rev, i): | ||||
| self._modecache = {} | self._modecache = {} | ||||
| curtree = self.sourcerepo.revision_tree(rev) | curtree = self.sourcerepo.revision_tree(rev) | ||||
| if i is not None: | if i is not None: | ||||
| parentid = self._parentids[rev][i] | parentid = self._parentids[rev][i] | ||||
| pass | pass | ||||
| def postrun(self): | def postrun(self): | ||||
| pass | pass | ||||
| def _cmdline(self, cmd, *args, **kwargs): | def _cmdline(self, cmd, *args, **kwargs): | ||||
| kwargs = pycompat.byteskwargs(kwargs) | kwargs = pycompat.byteskwargs(kwargs) | ||||
| cmdline = [self.command, cmd] + list(args) | cmdline = [self.command, cmd] + list(args) | ||||
| for k, v in pycompat.iteritems(kwargs): | for k, v in kwargs.items(): | ||||
| if len(k) == 1: | if len(k) == 1: | ||||
| cmdline.append(b'-' + k) | cmdline.append(b'-' + k) | ||||
| else: | else: | ||||
| cmdline.append(b'--' + k.replace(b'_', b'-')) | cmdline.append(b'--' + k.replace(b'_', b'-')) | ||||
| try: | try: | ||||
| if len(k) == 1: | if len(k) == 1: | ||||
| cmdline.append(b'' + v) | cmdline.append(b'' + v) | ||||
| else: | else: | ||||
| ctags[k] = self.map[v] | ctags[k] = self.map[v] | ||||
| if c and ctags: | if c and ctags: | ||||
| nrev, tagsparent = self.dest.puttags(ctags) | nrev, tagsparent = self.dest.puttags(ctags) | ||||
| if nrev and tagsparent: | if nrev and tagsparent: | ||||
| # write another hash correspondence to override the | # write another hash correspondence to override the | ||||
| # previous one so we don't end up with extra tag heads | # previous one so we don't end up with extra tag heads | ||||
| tagsparents = [ | tagsparents = [ | ||||
| e | e for e in self.map.items() if e[1] == tagsparent | ||||
| for e in pycompat.iteritems(self.map) | |||||
| if e[1] == tagsparent | |||||
| ] | ] | ||||
| if tagsparents: | if tagsparents: | ||||
| self.map[tagsparents[0][0]] = nrev | self.map[tagsparents[0][0]] = nrev | ||||
| bookmarks = self.source.getbookmarks() | bookmarks = self.source.getbookmarks() | ||||
| cbookmarks = {} | cbookmarks = {} | ||||
| for k in bookmarks: | for k in bookmarks: | ||||
| v = bookmarks[k] | v = bookmarks[k] | ||||
| revn = len(e.revision) | revn = len(e.revision) | ||||
| if revn > 3 and (revn % 2) == 0: | if revn > 3 and (revn % 2) == 0: | ||||
| e.branch = tags.get(e.revision[:-1], [None])[0] | e.branch = tags.get(e.revision[:-1], [None])[0] | ||||
| else: | else: | ||||
| e.branch = None | e.branch = None | ||||
| # find the branches starting from this revision | # find the branches starting from this revision | ||||
| branchpoints = set() | branchpoints = set() | ||||
| for branch, revision in pycompat.iteritems(branchmap): | for branch, revision in branchmap.items(): | ||||
| revparts = tuple([int(i) for i in revision.split(b'.')]) | revparts = tuple([int(i) for i in revision.split(b'.')]) | ||||
| if len(revparts) < 2: # bad tags | if len(revparts) < 2: # bad tags | ||||
| continue | continue | ||||
| if revparts[-2] == 0 and revparts[-1] % 2 == 0: | if revparts[-2] == 0 and revparts[-1] % 2 == 0: | ||||
| # normal branch | # normal branch | ||||
| if revparts[:-2] == e.revision: | if revparts[:-2] == e.revision: | ||||
| branchpoints.add(branch) | branchpoints.add(branch) | ||||
| elif revparts == (1, 1, 1): # vendor branch | elif revparts == (1, 1, 1): # vendor branch | ||||
| return b'', name, b'' | return b'', name, b'' | ||||
| def istargetfile(self, filename): | def istargetfile(self, filename): | ||||
| """Return true if the given target filename is covered as a destination | """Return true if the given target filename is covered as a destination | ||||
| of the filemap. This is useful for identifying what parts of the target | of the filemap. This is useful for identifying what parts of the target | ||||
| repo belong to the source repo and what parts don't.""" | repo belong to the source repo and what parts don't.""" | ||||
| if self.targetprefixes is None: | if self.targetprefixes is None: | ||||
| self.targetprefixes = set() | self.targetprefixes = set() | ||||
| for before, after in pycompat.iteritems(self.rename): | for before, after in self.rename.items(): | ||||
| self.targetprefixes.add(after) | self.targetprefixes.add(after) | ||||
| # If "." is a target, then all target files are considered from the | # If "." is a target, then all target files are considered from the | ||||
| # source. | # source. | ||||
| if not self.targetprefixes or b'.' in self.targetprefixes: | if not self.targetprefixes or b'.' in self.targetprefixes: | ||||
| return True | return True | ||||
| filename = normalize(filename) | filename = normalize(filename) | ||||
| for b in pbranches: | for b in pbranches: | ||||
| try: | try: | ||||
| self.repo.lookup(b[0]) | self.repo.lookup(b[0]) | ||||
| except Exception: | except Exception: | ||||
| missings.setdefault(b[1], []).append(b[0]) | missings.setdefault(b[1], []).append(b[0]) | ||||
| if missings: | if missings: | ||||
| self.after() | self.after() | ||||
| for pbranch, heads in sorted(pycompat.iteritems(missings)): | for pbranch, heads in sorted(missings.items()): | ||||
| pbranchpath = os.path.join(self.path, pbranch) | pbranchpath = os.path.join(self.path, pbranch) | ||||
| prepo = hg.peer(self.ui, {}, pbranchpath) | prepo = hg.peer(self.ui, {}, pbranchpath) | ||||
| self.ui.note( | self.ui.note( | ||||
| _(b'pulling from %s into %s\n') % (pbranch, branch) | _(b'pulling from %s into %s\n') % (pbranch, branch) | ||||
| ) | ) | ||||
| exchange.pull( | exchange.pull( | ||||
| self.repo, prepo, heads=[prepo.lookup(h) for h in heads] | self.repo, prepo, heads=[prepo.lookup(h) for h in heads] | ||||
| ) | ) | ||||
| except error.LookupError: | except error.LookupError: | ||||
| return None, None | return None, None | ||||
| def _changedfiles(self, ctx1, ctx2): | def _changedfiles(self, ctx1, ctx2): | ||||
| ma, r = [], [] | ma, r = [], [] | ||||
| maappend = ma.append | maappend = ma.append | ||||
| rappend = r.append | rappend = r.append | ||||
| d = ctx1.manifest().diff(ctx2.manifest()) | d = ctx1.manifest().diff(ctx2.manifest()) | ||||
| for f, ((node1, flag1), (node2, flag2)) in pycompat.iteritems(d): | for f, ((node1, flag1), (node2, flag2)) in d.items(): | ||||
| if node2 is None: | if node2 is None: | ||||
| rappend(f) | rappend(f) | ||||
| else: | else: | ||||
| maappend(f) | maappend(f) | ||||
| return ma, r | return ma, r | ||||
| def getchanges(self, rev, full): | def getchanges(self, rev, full): | ||||
| ctx = self._changectx(rev) | ctx = self._changectx(rev) | ||||
| files = ma + r | files = ma + r | ||||
| copyfiles = ma | copyfiles = ma | ||||
| # _getcopies() is also run for roots and before filtering so missing | # _getcopies() is also run for roots and before filtering so missing | ||||
| # revlogs are detected early | # revlogs are detected early | ||||
| copies = self._getcopies(ctx, parents, copyfiles) | copies = self._getcopies(ctx, parents, copyfiles) | ||||
| cleanp2 = set() | cleanp2 = set() | ||||
| if len(parents) == 2: | if len(parents) == 2: | ||||
| d = parents[1].manifest().diff(ctx.manifest(), clean=True) | d = parents[1].manifest().diff(ctx.manifest(), clean=True) | ||||
| for f, value in pycompat.iteritems(d): | for f, value in d.items(): | ||||
| if value is None: | if value is None: | ||||
| cleanp2.add(f) | cleanp2.add(f) | ||||
| changes = [(f, rev) for f in files if f not in self.ignored] | changes = [(f, rev) for f in files if f not in self.ignored] | ||||
| changes.sort() | changes.sort() | ||||
| return changes, copies, cleanp2 | return changes, copies, cleanp2 | ||||
| def _getcopies(self, ctx, parents, files): | def _getcopies(self, ctx, parents, files): | ||||
| copies = {} | copies = {} | ||||
| def mtnrunsingle(self, *args, **kwargs): | def mtnrunsingle(self, *args, **kwargs): | ||||
| kwargs['d'] = self.path | kwargs['d'] = self.path | ||||
| return self.run0(b'automate', *args, **kwargs) | return self.run0(b'automate', *args, **kwargs) | ||||
| def mtnrunstdio(self, *args, **kwargs): | def mtnrunstdio(self, *args, **kwargs): | ||||
| # Prepare the command in automate stdio format | # Prepare the command in automate stdio format | ||||
| kwargs = pycompat.byteskwargs(kwargs) | kwargs = pycompat.byteskwargs(kwargs) | ||||
| command = [] | command = [] | ||||
| for k, v in pycompat.iteritems(kwargs): | for k, v in kwargs.items(): | ||||
| command.append(b"%d:%s" % (len(k), k)) | command.append(b"%d:%s" % (len(k), k)) | ||||
| if v: | if v: | ||||
| command.append(b"%d:%s" % (len(v), v)) | command.append(b"%d:%s" % (len(v), v)) | ||||
| if command: | if command: | ||||
| command.insert(0, b'o') | command.insert(0, b'o') | ||||
| command.append(b'e') | command.append(b'e') | ||||
| command.append(b'l') | command.append(b'l') | ||||
| discover_changed_paths=True, | discover_changed_paths=True, | ||||
| strict_node_history=False, | strict_node_history=False, | ||||
| ): | ): | ||||
| protocol = -1 | protocol = -1 | ||||
| def receiver(orig_paths, revnum, author, date, message, pool): | def receiver(orig_paths, revnum, author, date, message, pool): | ||||
| paths = {} | paths = {} | ||||
| if orig_paths is not None: | if orig_paths is not None: | ||||
| for k, v in pycompat.iteritems(orig_paths): | for k, v in orig_paths.items(): | ||||
| paths[k] = changedpath(v) | paths[k] = changedpath(v) | ||||
| pickle.dump((paths, revnum, author, date, message), fp, protocol) | pickle.dump((paths, revnum, author, date, message), fp, protocol) | ||||
| try: | try: | ||||
| # Use an ra of our own so that our parent can consume | # Use an ra of our own so that our parent can consume | ||||
| # our results without confusing the server. | # our results without confusing the server. | ||||
| t = transport.SvnRaTransport(url=url) | t = transport.SvnRaTransport(url=url) | ||||
| svn.ra.get_log( | svn.ra.get_log( | ||||
| end, | end, | ||||
| limit=0, | limit=0, | ||||
| discover_changed_paths=True, | discover_changed_paths=True, | ||||
| strict_node_history=False, | strict_node_history=False, | ||||
| ): | ): | ||||
| def receiver(orig_paths, revnum, author, date, message, pool): | def receiver(orig_paths, revnum, author, date, message, pool): | ||||
| paths = {} | paths = {} | ||||
| if orig_paths is not None: | if orig_paths is not None: | ||||
| for k, v in pycompat.iteritems(orig_paths): | for k, v in orig_paths.items(): | ||||
| paths[k] = changedpath(v) | paths[k] = changedpath(v) | ||||
| self.append((paths, revnum, author, date, message)) | self.append((paths, revnum, author, date, message)) | ||||
| # Use an ra of our own so that our parent can consume | # Use an ra of our own so that our parent can consume | ||||
| # our results without confusing the server. | # our results without confusing the server. | ||||
| t = transport.SvnRaTransport(url=url) | t = transport.SvnRaTransport(url=url) | ||||
| svn.ra.get_log( | svn.ra.get_log( | ||||
| t.ra, | t.ra, | ||||
| if full or not parents: | if full or not parents: | ||||
| # Perform a full checkout on roots | # Perform a full checkout on roots | ||||
| uuid, module, revnum = revsplit(rev) | uuid, module, revnum = revsplit(rev) | ||||
| entries = svn.client.ls( | entries = svn.client.ls( | ||||
| self.baseurl + quote(module), optrev(revnum), True, self.ctx | self.baseurl + quote(module), optrev(revnum), True, self.ctx | ||||
| ) | ) | ||||
| files = [ | files = [ | ||||
| n | n | ||||
| for n, e in pycompat.iteritems(entries) | for n, e in entries.items() | ||||
| if e.kind == svn.core.svn_node_file | if e.kind == svn.core.svn_node_file | ||||
| ] | ] | ||||
| self.removed = set() | self.removed = set() | ||||
| files.sort() | files.sort() | ||||
| files = pycompat.ziplist(files, [rev] * len(files)) | files = pycompat.ziplist(files, [rev] * len(files)) | ||||
| return (files, copies) | return (files, copies) | ||||
| stream = self._getlog([self.tags], start, self.startrev) | stream = self._getlog([self.tags], start, self.startrev) | ||||
| try: | try: | ||||
| for entry in stream: | for entry in stream: | ||||
| origpaths, revnum, author, date, message = entry | origpaths, revnum, author, date, message = entry | ||||
| if not origpaths: | if not origpaths: | ||||
| origpaths = [] | origpaths = [] | ||||
| copies = [ | copies = [ | ||||
| (e.copyfrom_path, e.copyfrom_rev, p) | (e.copyfrom_path, e.copyfrom_rev, p) | ||||
| for p, e in pycompat.iteritems(origpaths) | for p, e in origpaths.items() | ||||
| if e.copyfrom_path | if e.copyfrom_path | ||||
| ] | ] | ||||
| # Apply moves/copies from more specific to general | # Apply moves/copies from more specific to general | ||||
| copies.sort(reverse=True) | copies.sort(reverse=True) | ||||
| srctagspath = tagspath | srctagspath = tagspath | ||||
| if copies and copies[-1][2] == tagspath: | if copies and copies[-1][2] == tagspath: | ||||
| # Track tags directory moves | # Track tags directory moves | ||||
| # parts of the repository like: | # parts of the repository like: | ||||
| # /tags/tag.1 (from /trunk:10) | # /tags/tag.1 (from /trunk:10) | ||||
| # /tags/tag.1/foo (from /branches/foo:12) | # /tags/tag.1/foo (from /branches/foo:12) | ||||
| # Here/tags/tag.1 discarded as well as its children. | # Here/tags/tag.1 discarded as well as its children. | ||||
| # It happens with tools like cvs2svn. Such tags cannot | # It happens with tools like cvs2svn. Such tags cannot | ||||
| # be represented in mercurial. | # be represented in mercurial. | ||||
| addeds = { | addeds = { | ||||
| p: e.copyfrom_path | p: e.copyfrom_path | ||||
| for p, e in pycompat.iteritems(origpaths) | for p, e in origpaths.items() | ||||
| if e.action == b'A' and e.copyfrom_path | if e.action == b'A' and e.copyfrom_path | ||||
| } | } | ||||
| badroots = set() | badroots = set() | ||||
| for destroot in addeds: | for destroot in addeds: | ||||
| for source, sourcerev, dest in pendings: | for source, sourcerev, dest in pendings: | ||||
| if not dest.startswith( | if not dest.startswith( | ||||
| destroot + b'/' | destroot + b'/' | ||||
| ) or source.startswith(addeds[destroot] + b'/'): | ) or source.startswith(addeds[destroot] + b'/'): | ||||
| # branch log might return entries for a parent we already have | # branch log might return entries for a parent we already have | ||||
| if rev in self.commits or revnum < to_revnum: | if rev in self.commits or revnum < to_revnum: | ||||
| return None, branched | return None, branched | ||||
| parents = [] | parents = [] | ||||
| # check whether this revision is the start of a branch or part | # check whether this revision is the start of a branch or part | ||||
| # of a branch renaming | # of a branch renaming | ||||
| orig_paths = sorted(pycompat.iteritems(orig_paths)) | orig_paths = sorted(orig_paths.items()) | ||||
| root_paths = [ | root_paths = [ | ||||
| (p, e) for p, e in orig_paths if self.module.startswith(p) | (p, e) for p, e in orig_paths if self.module.startswith(p) | ||||
| ] | ] | ||||
| if root_paths: | if root_paths: | ||||
| path, ent = root_paths[-1] | path, ent = root_paths[-1] | ||||
| if ent.copyfrom_path: | if ent.copyfrom_path: | ||||
| branched = True | branched = True | ||||
| newpath = ent.copyfrom_path + self.module[len(path) :] | newpath = ent.copyfrom_path + self.module[len(path) :] | ||||
| path = path.strip(b'/') | path = path.strip(b'/') | ||||
| pool = svn.core.Pool() | pool = svn.core.Pool() | ||||
| rpath = b'/'.join([self.baseurl, quote(path)]).strip(b'/') | rpath = b'/'.join([self.baseurl, quote(path)]).strip(b'/') | ||||
| entries = svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool) | entries = svn.client.ls(rpath, optrev(revnum), True, self.ctx, pool) | ||||
| if path: | if path: | ||||
| path += b'/' | path += b'/' | ||||
| return ( | return ( | ||||
| (path + p) | (path + p) | ||||
| for p, e in pycompat.iteritems(entries) | for p, e in entries.items() | ||||
| if e.kind == svn.core.svn_node_file | if e.kind == svn.core.svn_node_file | ||||
| ) | ) | ||||
| def getrelpath(self, path, module=None): | def getrelpath(self, path, module=None): | ||||
| if module is None: | if module is None: | ||||
| module = self.module | module = self.module | ||||
| # Given the repository url of this wc, say | # Given the repository url of this wc, say | ||||
| # "http://server/plone/CMFPlone/branches/Plone-2_0-branch" | # "http://server/plone/CMFPlone/branches/Plone-2_0-branch" | ||||
| pass | pass | ||||
| def reposetup(ui, repo): | def reposetup(ui, repo): | ||||
| uisetup(repo.ui) | uisetup(repo.ui) | ||||
| if not repo.local(): | if not repo.local(): | ||||
| return | return | ||||
| for name, fn in pycompat.iteritems(filters): | for name, fn in filters.items(): | ||||
| repo.adddatafilter(name, fn) | repo.adddatafilter(name, fn) | ||||
| ui.setconfig(b'patch', b'eol', b'auto', b'eol') | ui.setconfig(b'patch', b'eol', b'auto', b'eol') | ||||
| class eolrepo(repo.__class__): | class eolrepo(repo.__class__): | ||||
| def loadeol(self, nodes): | def loadeol(self, nodes): | ||||
| eol = parseeol(self.ui, self, nodes) | eol = parseeol(self.ui, self, nodes) | ||||
| if eol is None: | if eol is None: | ||||
| defaults = { | defaults = { | ||||
| b'diffopts': None, | b'diffopts': None, | ||||
| b'followrename': True, | b'followrename': True, | ||||
| b'followmerge': True, | b'followmerge': True, | ||||
| } | } | ||||
| def __init__(self, **opts): | def __init__(self, **opts): | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| for k, v in pycompat.iteritems(self.defaults): | for k, v in self.defaults.items(): | ||||
| setattr(self, k, opts.get(k, v)) | setattr(self, k, opts.get(k, v)) | ||||
| @util.propertycache | @util.propertycache | ||||
| def shortstr(self): | def shortstr(self): | ||||
| """represent opts in a short string, suitable for a directory name""" | """represent opts in a short string, suitable for a directory name""" | ||||
| result = b'' | result = b'' | ||||
| if not self.followrename: | if not self.followrename: | ||||
| result += b'r0' | result += b'r0' | ||||
| # {(rev, linenum): [lineindex]} | # {(rev, linenum): [lineindex]} | ||||
| key2idxs = collections.defaultdict(list) | key2idxs = collections.defaultdict(list) | ||||
| for i in pycompat.xrange(len(result)): | for i in pycompat.xrange(len(result)): | ||||
| key2idxs[(revs[i], annotateresult[i][1])].append(i) | key2idxs[(revs[i], annotateresult[i][1])].append(i) | ||||
| while key2idxs: | while key2idxs: | ||||
| # find an unresolved line and its linelog rev to annotate | # find an unresolved line and its linelog rev to annotate | ||||
| hsh = None | hsh = None | ||||
| try: | try: | ||||
| for (rev, _linenum), idxs in pycompat.iteritems(key2idxs): | for (rev, _linenum), idxs in key2idxs.items(): | ||||
| if revmap.rev2flag(rev) & revmapmod.sidebranchflag: | if revmap.rev2flag(rev) & revmapmod.sidebranchflag: | ||||
| continue | continue | ||||
| hsh = annotateresult[idxs[0]][0] | hsh = annotateresult[idxs[0]][0] | ||||
| break | break | ||||
| except StopIteration: # no more unresolved lines | except StopIteration: # no more unresolved lines | ||||
| return result | return result | ||||
| if hsh is None: | if hsh is None: | ||||
| # the remaining key2idxs are not in main branch, resolving them | # the remaining key2idxs are not in main branch, resolving them | ||||
| # using the hard way... | # using the hard way... | ||||
| revlines = {} | revlines = {} | ||||
| for (rev, linenum), idxs in pycompat.iteritems(key2idxs): | for (rev, linenum), idxs in key2idxs.items(): | ||||
| if rev not in revlines: | if rev not in revlines: | ||||
| hsh = annotateresult[idxs[0]][0] | hsh = annotateresult[idxs[0]][0] | ||||
| if self.ui.debugflag: | if self.ui.debugflag: | ||||
| self.ui.debug( | self.ui.debug( | ||||
| b'fastannotate: reading %s line #%d ' | b'fastannotate: reading %s line #%d ' | ||||
| b'to resolve lines %r\n' | b'to resolve lines %r\n' | ||||
| % (short(hsh), linenum, idxs) | % (short(hsh), linenum, idxs) | ||||
| ) | ) | ||||
| # Copyright 2016-present Facebook. All Rights Reserved. | # Copyright 2016-present Facebook. All Rights Reserved. | ||||
| # | # | ||||
| # protocol: logic for a server providing fastannotate support | # protocol: logic for a server providing fastannotate support | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| import contextlib | import contextlib | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.pycompat import open | from mercurial.pycompat import open | ||||
| from mercurial import ( | from mercurial import ( | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| hg, | hg, | ||||
| pycompat, | |||||
| util, | util, | ||||
| wireprotov1peer, | wireprotov1peer, | ||||
| wireprotov1server, | wireprotov1server, | ||||
| ) | ) | ||||
| from mercurial.utils import ( | from mercurial.utils import ( | ||||
| urlutil, | urlutil, | ||||
| ) | ) | ||||
| from . import context | from . import context | ||||
| b'getannotate', | b'getannotate', | ||||
| {b'path': p, b'lastnode': lastnodemap.get(p)}, | {b'path': p, b'lastnode': lastnodemap.get(p)}, | ||||
| ) | ) | ||||
| ) | ) | ||||
| for result in results: | for result in results: | ||||
| r = result.result() | r = result.result() | ||||
| # TODO: pconvert these paths on the server? | # TODO: pconvert these paths on the server? | ||||
| r = {util.pconvert(p): v for p, v in pycompat.iteritems(r)} | r = {util.pconvert(p): v for p, v in r.items()} | ||||
| for path in sorted(r): | for path in sorted(r): | ||||
| # ignore malicious paths | # ignore malicious paths | ||||
| if not path.startswith(b'fastannotate/') or b'/../' in ( | if not path.startswith(b'fastannotate/') or b'/../' in ( | ||||
| path + b'/' | path + b'/' | ||||
| ): | ): | ||||
| ui.debug( | ui.debug( | ||||
| b'fastannotate: ignored malicious path %s\n' % path | b'fastannotate: ignored malicious path %s\n' % path | ||||
| ) | ) | ||||
| from cleanupnodes(). | from cleanupnodes(). | ||||
| "wdirwritten" is a bool which tells whether the working copy was affected by | "wdirwritten" is a bool which tells whether the working copy was affected by | ||||
| fixing, since it has no entry in "replacements". | fixing, since it has no entry in "replacements". | ||||
| Useful as a hook point for extending "hg fix" with output summarizing the | Useful as a hook point for extending "hg fix" with output summarizing the | ||||
| effects of the command, though we choose not to output anything here. | effects of the command, though we choose not to output anything here. | ||||
| """ | """ | ||||
| replacements = { | replacements = {prec: [succ] for prec, succ in replacements.items()} | ||||
| prec: [succ] for prec, succ in pycompat.iteritems(replacements) | |||||
| } | |||||
| scmutil.cleanupnodes(repo, replacements, b'fix', fixphase=True) | scmutil.cleanupnodes(repo, replacements, b'fix', fixphase=True) | ||||
| def getworkqueue(ui, repo, pats, opts, revstofix, basectxs): | def getworkqueue(ui, repo, pats, opts, revstofix, basectxs): | ||||
| """Constructs a list of files to fix and which revisions each fix applies to | """Constructs a list of files to fix and which revisions each fix applies to | ||||
| To avoid duplicating work, there is usually only one work item for each file | To avoid duplicating work, there is usually only one work item for each file | ||||
| revision that might need to be fixed. There can be multiple work items per | revision that might need to be fixed. There can be multiple work items per | ||||
| (i.e. they will only avoid lines that are common to all basectxs). | (i.e. they will only avoid lines that are common to all basectxs). | ||||
| A fixer tool's stdout will become the file's new content if and only if it | A fixer tool's stdout will become the file's new content if and only if it | ||||
| exits with code zero. The fixer tool's working directory is the repository's | exits with code zero. The fixer tool's working directory is the repository's | ||||
| root. | root. | ||||
| """ | """ | ||||
| metadata = {} | metadata = {} | ||||
| newdata = fixctx[path].data() | newdata = fixctx[path].data() | ||||
| for fixername, fixer in pycompat.iteritems(fixers): | for fixername, fixer in fixers.items(): | ||||
| if fixer.affects(opts, fixctx, path): | if fixer.affects(opts, fixctx, path): | ||||
| ranges = lineranges( | ranges = lineranges( | ||||
| opts, path, basepaths, basectxs, fixctx, newdata | opts, path, basepaths, basectxs, fixctx, newdata | ||||
| ) | ) | ||||
| command = fixer.command(ui, path, ranges) | command = fixer.command(ui, path, ranges) | ||||
| if command is None: | if command is None: | ||||
| continue | continue | ||||
| ui.debug(b'subprocess: %s\n' % (command,)) | ui.debug(b'subprocess: %s\n' % (command,)) | ||||
| We check out a new revision if and only if we fixed something in both the | We check out a new revision if and only if we fixed something in both the | ||||
| working directory and its parent revision. This avoids the need for a full | working directory and its parent revision. This avoids the need for a full | ||||
| update/merge, and means that the working directory simply isn't affected | update/merge, and means that the working directory simply isn't affected | ||||
| unless the --working-dir flag is given. | unless the --working-dir flag is given. | ||||
| Directly updates the dirstate for the affected files. | Directly updates the dirstate for the affected files. | ||||
| """ | """ | ||||
| for path, data in pycompat.iteritems(filedata): | for path, data in filedata.items(): | ||||
| fctx = ctx[path] | fctx = ctx[path] | ||||
| fctx.write(data, fctx.flags()) | fctx.write(data, fctx.flags()) | ||||
| oldp1 = repo.dirstate.p1() | oldp1 = repo.dirstate.p1() | ||||
| newp1 = replacements.get(oldp1, oldp1) | newp1 = replacements.get(oldp1, oldp1) | ||||
| if newp1 != oldp1: | if newp1 != oldp1: | ||||
| assert repo.dirstate.p2() == nullid | assert repo.dirstate.p2() == nullid | ||||
| with repo.dirstate.parentchange(): | with repo.dirstate.parentchange(): | ||||
| visit.update(f for f in copymap if f not in results) | visit.update(f for f in copymap if f not in results) | ||||
| else: | else: | ||||
| visit.update( | visit.update( | ||||
| f for f in nonnormalset if f not in results and matchfn(f) | f for f in nonnormalset if f not in results and matchfn(f) | ||||
| ) | ) | ||||
| visit.update(f for f in copymap if f not in results and matchfn(f)) | visit.update(f for f in copymap if f not in results and matchfn(f)) | ||||
| else: | else: | ||||
| if matchalways: | if matchalways: | ||||
| visit.update( | visit.update(f for f, st in dmap.items() if f not in results) | ||||
| f for f, st in pycompat.iteritems(dmap) if f not in results | |||||
| ) | |||||
| visit.update(f for f in copymap if f not in results) | visit.update(f for f in copymap if f not in results) | ||||
| else: | else: | ||||
| visit.update( | visit.update( | ||||
| f | f for f, st in dmap.items() if f not in results and matchfn(f) | ||||
| for f, st in pycompat.iteritems(dmap) | |||||
| if f not in results and matchfn(f) | |||||
| ) | ) | ||||
| visit.update(f for f in copymap if f not in results and matchfn(f)) | visit.update(f for f in copymap if f not in results and matchfn(f)) | ||||
| audit = pathutil.pathauditor(self._root, cached=True).check | audit = pathutil.pathauditor(self._root, cached=True).check | ||||
| auditpass = [f for f in visit if audit(f)] | auditpass = [f for f in visit if audit(f)] | ||||
| auditpass.sort() | auditpass.sort() | ||||
| auditfail = visit.difference(auditpass) | auditfail = visit.difference(auditpass) | ||||
| for f in auditfail: | for f in auditfail: | ||||
| ) | ) | ||||
| ui.warn(_(b"ignoring unknown option %s\n") % flag) | ui.warn(_(b"ignoring unknown option %s\n") % flag) | ||||
| args = list([convert(x) for x in args]) | args = list([convert(x) for x in args]) | ||||
| opts = dict( | opts = dict( | ||||
| [ | [ | ||||
| (k, convert(v)) if isinstance(v, bytes) else (k, v) | (k, convert(v)) if isinstance(v, bytes) else (k, v) | ||||
| for k, v in pycompat.iteritems(opts) | for k, v in opts.items() | ||||
| ] | ] | ||||
| ) | ) | ||||
| return args, opts | return args, opts | ||||
| class Command(object): | class Command(object): | ||||
| def __init__(self, name): | def __init__(self, name): | ||||
| self.name = name | self.name = name | ||||
| self.args = [] | self.args = [] | ||||
| self.opts = {} | self.opts = {} | ||||
| def __bytes__(self): | def __bytes__(self): | ||||
| cmd = b"hg " + self.name | cmd = b"hg " + self.name | ||||
| if self.opts: | if self.opts: | ||||
| for k, values in sorted(pycompat.iteritems(self.opts)): | for k, values in sorted(self.opts.items()): | ||||
| for v in values: | for v in values: | ||||
| if v: | if v: | ||||
| if isinstance(v, int): | if isinstance(v, int): | ||||
| fmt = b' %s %d' | fmt = b' %s %d' | ||||
| else: | else: | ||||
| fmt = b' %s %s' | fmt = b' %s %s' | ||||
| cmd += fmt % (k, v) | cmd += fmt % (k, v) | ||||
| [(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): | ||||
| """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 opts.items() 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') | ||||
| def _finishhistedit(ui, repo, state, fm): | def _finishhistedit(ui, repo, state, fm): | ||||
| """This action runs when histedit is finishing its session""" | """This action runs when histedit is finishing its session""" | ||||
| mergemod.update(repo[state.parentctxnode]) | mergemod.update(repo[state.parentctxnode]) | ||||
| mapping, tmpnodes, created, ntm = processreplacement(state) | mapping, tmpnodes, created, ntm = processreplacement(state) | ||||
| if mapping: | if mapping: | ||||
| for prec, succs in pycompat.iteritems(mapping): | for prec, succs in mapping.items(): | ||||
| if not succs: | if not succs: | ||||
| ui.debug(b'histedit: %s is dropped\n' % short(prec)) | ui.debug(b'histedit: %s is dropped\n' % short(prec)) | ||||
| else: | else: | ||||
| ui.debug( | ui.debug( | ||||
| b'histedit: %s is replaced by %s\n' | b'histedit: %s is replaced by %s\n' | ||||
| % (short(prec), short(succs[0])) | % (short(prec), short(succs[0])) | ||||
| ) | ) | ||||
| if len(succs) > 1: | if len(succs) > 1: | ||||
| } | } | ||||
| scmutil.cleanupnodes(repo, mapping, b'histedit') | scmutil.cleanupnodes(repo, mapping, b'histedit') | ||||
| hf = fm.hexfunc | hf = fm.hexfunc | ||||
| fl = fm.formatlist | fl = fm.formatlist | ||||
| fd = fm.formatdict | fd = fm.formatdict | ||||
| nodechanges = fd( | nodechanges = fd( | ||||
| { | { | ||||
| hf(oldn): fl([hf(n) for n in newn], name=b'node') | hf(oldn): fl([hf(n) for n in newn], name=b'node') | ||||
| for oldn, newn in pycompat.iteritems(mapping) | for oldn, newn in mapping.items() | ||||
| }, | }, | ||||
| key=b"oldnode", | key=b"oldnode", | ||||
| value=b"newnodes", | value=b"newnodes", | ||||
| ) | ) | ||||
| fm.data(nodechanges=nodechanges) | fm.data(nodechanges=nodechanges) | ||||
| state.clear() | state.clear() | ||||
| if os.path.exists(repo.sjoin(b'undo')): | if os.path.exists(repo.sjoin(b'undo')): | ||||
| if fword.endswith(b'!'): | if fword.endswith(b'!'): | ||||
| fword = fword[:-1] | fword = fword[:-1] | ||||
| if fword in primaryactions | secondaryactions | tertiaryactions: | if fword in primaryactions | secondaryactions | tertiaryactions: | ||||
| act.verb = fword | act.verb = fword | ||||
| # get the target summary | # get the target summary | ||||
| tsum = summary[len(fword) + 1 :].lstrip() | tsum = summary[len(fword) + 1 :].lstrip() | ||||
| # safe but slow: reverse iterate over the actions so we | # safe but slow: reverse iterate over the actions so we | ||||
| # don't clash on two commits having the same summary | # don't clash on two commits having the same summary | ||||
| for na, l in reversed(list(pycompat.iteritems(newact))): | for na, l in reversed(list(newact.items())): | ||||
| actx = repo[na.node] | actx = repo[na.node] | ||||
| asum = _getsummary(actx) | asum = _getsummary(actx) | ||||
| if asum == tsum: | if asum == tsum: | ||||
| added = True | added = True | ||||
| l.append(act) | l.append(act) | ||||
| break | break | ||||
| if not added: | if not added: | ||||
| newact[act] = [] | newact[act] = [] | ||||
| # copy over and flatten the new list | # copy over and flatten the new list | ||||
| actions = [] | actions = [] | ||||
| for na, l in pycompat.iteritems(newact): | for na, l in newact.items(): | ||||
| actions.append(na) | actions.append(na) | ||||
| actions += l | actions += l | ||||
| rules = b'\n'.join([act.torule() for act in actions]) | rules = b'\n'.join([act.torule() for act in actions]) | ||||
| rules += b'\n\n' | rules += b'\n\n' | ||||
| rules += editcomment | rules += editcomment | ||||
| rules = ui.edit( | rules = ui.edit( | ||||
| rules, | rules, | ||||
| index = self.bundlestore.index | index = self.bundlestore.index | ||||
| results = {} | results = {} | ||||
| bookmarks = orig(self, namespace) | bookmarks = orig(self, namespace) | ||||
| for pattern in patterns: | for pattern in patterns: | ||||
| results.update(index.getbookmarks(pattern)) | results.update(index.getbookmarks(pattern)) | ||||
| if pattern.endswith(b'*'): | if pattern.endswith(b'*'): | ||||
| pattern = b're:^' + pattern[:-1] + b'.*' | pattern = b're:^' + pattern[:-1] + b'.*' | ||||
| kind, pat, matcher = stringutil.stringmatcher(pattern) | kind, pat, matcher = stringutil.stringmatcher(pattern) | ||||
| for bookmark, node in pycompat.iteritems(bookmarks): | for bookmark, node in bookmarks.items(): | ||||
| if matcher(bookmark): | if matcher(bookmark): | ||||
| results[bookmark] = node | results[bookmark] = node | ||||
| return results | return results | ||||
| else: | else: | ||||
| return orig(self, namespace) | return orig(self, namespace) | ||||
| @wireprotov1peer.batchable | @wireprotov1peer.batchable | ||||
| part.addparam(b'version', b'01') | part.addparam(b'version', b'01') | ||||
| parts.append(part) | parts.append(part) | ||||
| elif isinstance(unbundler, bundle2.unbundle20): | elif isinstance(unbundler, bundle2.unbundle20): | ||||
| haschangegroup = False | haschangegroup = False | ||||
| for part in unbundler.iterparts(): | for part in unbundler.iterparts(): | ||||
| if part.type == b'changegroup': | if part.type == b'changegroup': | ||||
| haschangegroup = True | haschangegroup = True | ||||
| newpart = bundle2.bundlepart(part.type, data=part.read()) | newpart = bundle2.bundlepart(part.type, data=part.read()) | ||||
| for key, value in pycompat.iteritems(part.params): | for key, value in part.params.items(): | ||||
| newpart.addparam(key, value) | newpart.addparam(key, value) | ||||
| parts.append(newpart) | parts.append(newpart) | ||||
| if not haschangegroup: | if not haschangegroup: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| b'unexpected bundle without changegroup part, ' | b'unexpected bundle without changegroup part, ' | ||||
| + b'head: %s' % hex(head), | + b'head: %s' % hex(head), | ||||
| hint=b'report to administrator', | hint=b'report to administrator', | ||||
| # scratch branch pattern. In this case just use the current | # scratch branch pattern. In this case just use the current | ||||
| # bookmark node | # bookmark node | ||||
| del newbookmarks[rname] | del newbookmarks[rname] | ||||
| bookmarks[rname] = hexnode | bookmarks[rname] = hexnode | ||||
| elif nametype == b'branches': | elif nametype == b'branches': | ||||
| # saveremotenames expects 20 byte binary nodes for branches | # saveremotenames expects 20 byte binary nodes for branches | ||||
| branches[rname].append(bin(hexnode)) | branches[rname].append(bin(hexnode)) | ||||
| for bookmark, hexnode in pycompat.iteritems(newbookmarks): | for bookmark, hexnode in newbookmarks.items(): | ||||
| bookmarks[bookmark] = hexnode | bookmarks[bookmark] = hexnode | ||||
| remotenamesext.saveremotenames(repo, remotepath, branches, bookmarks) | remotenamesext.saveremotenames(repo, remotepath, branches, bookmarks) | ||||
| def _savelocalbookmarks(repo, bookmarks): | def _savelocalbookmarks(repo, bookmarks): | ||||
| if not bookmarks: | if not bookmarks: | ||||
| return | return | ||||
| with repo.wlock(), repo.lock(), repo.transaction(b'bookmark') as tr: | with repo.wlock(), repo.lock(), repo.transaction(b'bookmark') as tr: | ||||
| changes = [] | changes = [] | ||||
| for scratchbook, node in pycompat.iteritems(bookmarks): | for scratchbook, node in bookmarks.items(): | ||||
| changectx = repo[node] | changectx = repo[node] | ||||
| changes.append((scratchbook, changectx.node())) | changes.append((scratchbook, changectx.node())) | ||||
| repo._bookmarks.applychanges(repo, tr, changes) | repo._bookmarks.applychanges(repo, tr, changes) | ||||
| def _findcommonincoming(orig, *args, **kwargs): | def _findcommonincoming(orig, *args, **kwargs): | ||||
| common, inc, remoteheads = orig(*args, **kwargs) | common, inc, remoteheads = orig(*args, **kwargs) | ||||
| return common, True, remoteheads | return common, True, remoteheads | ||||
| with bundle2.partiterator(repo, op, unbundler) as parts: | with bundle2.partiterator(repo, op, unbundler) as parts: | ||||
| for part in parts: | for part in parts: | ||||
| bundlepart = None | bundlepart = None | ||||
| if part.type == b'replycaps': | if part.type == b'replycaps': | ||||
| # This configures the current operation to allow reply parts. | # This configures the current operation to allow reply parts. | ||||
| bundle2._processpart(op, part) | bundle2._processpart(op, part) | ||||
| else: | else: | ||||
| bundlepart = bundle2.bundlepart(part.type, data=part.read()) | bundlepart = bundle2.bundlepart(part.type, data=part.read()) | ||||
| for key, value in pycompat.iteritems(part.params): | for key, value in part.params.items(): | ||||
| bundlepart.addparam(key, value) | bundlepart.addparam(key, value) | ||||
| # Certain parts require a response | # Certain parts require a response | ||||
| if part.type in (b'pushkey', b'changegroup'): | if part.type in (b'pushkey', b'changegroup'): | ||||
| if op.reply is not None: | if op.reply is not None: | ||||
| rpart = op.reply.newpart(b'reply:%s' % part.type) | rpart = op.reply.newpart(b'reply:%s' % part.type) | ||||
| rpart.addparam( | rpart.addparam( | ||||
| b'in-reply-to', b'%d' % part.id, mandatory=False | b'in-reply-to', b'%d' % part.id, mandatory=False | ||||
| ) | ) | ||||
| else: | else: | ||||
| if handleallparts: | if handleallparts: | ||||
| # Ideally we would not process any parts, and instead just | # Ideally we would not process any parts, and instead just | ||||
| # forward them to the bundle for storage, but since this | # forward them to the bundle for storage, but since this | ||||
| # differs from previous behavior, we need to put it behind a | # differs from previous behavior, we need to put it behind a | ||||
| # config flag for incremental rollout. | # config flag for incremental rollout. | ||||
| bundlepart = bundle2.bundlepart(part.type, data=part.read()) | bundlepart = bundle2.bundlepart(part.type, data=part.read()) | ||||
| for key, value in pycompat.iteritems(part.params): | for key, value in part.params.items(): | ||||
| bundlepart.addparam(key, value) | bundlepart.addparam(key, value) | ||||
| # Certain parts require a response | # Certain parts require a response | ||||
| if part.type == b'pushkey': | if part.type == b'pushkey': | ||||
| if op.reply is not None: | if op.reply is not None: | ||||
| rpart = op.reply.newpart(b'reply:pushkey') | rpart = op.reply.newpart(b'reply:pushkey') | ||||
| rpart.addparam( | rpart.addparam( | ||||
| b'in-reply-to', str(part.id), mandatory=False | b'in-reply-to', str(part.id), mandatory=False | ||||
| if params.get(b'pushbackbookmarks'): | if params.get(b'pushbackbookmarks'): | ||||
| if op.reply and b'pushback' in op.reply.capabilities: | if op.reply and b'pushback' in op.reply.capabilities: | ||||
| params = { | params = { | ||||
| b'namespace': b'bookmarks', | b'namespace': b'bookmarks', | ||||
| b'key': bookmark, | b'key': bookmark, | ||||
| b'new': newnode, | b'new': newnode, | ||||
| b'old': oldnode, | b'old': oldnode, | ||||
| } | } | ||||
| op.reply.newpart( | op.reply.newpart(b'pushkey', mandatoryparams=params.items()) | ||||
| b'pushkey', mandatoryparams=pycompat.iteritems(params) | |||||
| ) | |||||
| def bundle2pushkey(orig, op, part): | def bundle2pushkey(orig, op, part): | ||||
| """Wrapper of bundle2.handlepushkey() | """Wrapper of bundle2.handlepushkey() | ||||
| The only goal is to skip calling the original function if flag is set. | The only goal is to skip calling the original function if flag is set. | ||||
| It's set if infinitepush push is happening. | It's set if infinitepush push is happening. | ||||
| """ | """ | ||||
| # Copyright 2017 Facebook, Inc. | # Copyright 2017 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import hex | from mercurial.node import hex | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bundle2, | bundle2, | ||||
| changegroup, | changegroup, | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| pycompat, | |||||
| revsetlang, | revsetlang, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from . import common | from . import common | ||||
| isremotebooksenabled = common.isremotebooksenabled | isremotebooksenabled = common.isremotebooksenabled | ||||
| parts = [] | parts = [] | ||||
| # .upper() marks this as a mandatory part: server will abort if there's no | # .upper() marks this as a mandatory part: server will abort if there's no | ||||
| # handler | # handler | ||||
| parts.append( | parts.append( | ||||
| bundle2.bundlepart( | bundle2.bundlepart( | ||||
| scratchbranchparttype.upper(), | scratchbranchparttype.upper(), | ||||
| advisoryparams=pycompat.iteritems(params), | advisoryparams=params.items(), | ||||
| data=cg, | data=cg, | ||||
| ) | ) | ||||
| ) | ) | ||||
| return parts | return parts | ||||
| def _validaterevset(repo, revset, bookmark): | def _validaterevset(repo, revset, bookmark): | ||||
| # Infinite push | # Infinite push | ||||
| # | # | ||||
| # Copyright 2016 Facebook, Inc. | # Copyright 2016 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| import logging | import logging | ||||
| import os | import os | ||||
| import time | import time | ||||
| import warnings | import warnings | ||||
| import mysql.connector | import mysql.connector | ||||
| from mercurial import pycompat | |||||
| from . import indexapi | from . import indexapi | ||||
| def _convertbookmarkpattern(pattern): | def _convertbookmarkpattern(pattern): | ||||
| pattern = pattern.replace(b'_', b'\\_') | pattern = pattern.replace(b'_', b'\\_') | ||||
| pattern = pattern.replace(b'%', b'\\%') | pattern = pattern.replace(b'%', b'\\%') | ||||
| if pattern.endswith(b'*'): | if pattern.endswith(b'*'): | ||||
| pattern = pattern[:-1] + b'%' | pattern = pattern[:-1] + b'%' | ||||
| params=(bookmark, node, self.reponame), | params=(bookmark, node, self.reponame), | ||||
| ) | ) | ||||
| def addmanybookmarks(self, bookmarks): | def addmanybookmarks(self, bookmarks): | ||||
| if not self._connected: | if not self._connected: | ||||
| self.sqlconnect() | self.sqlconnect() | ||||
| args = [] | args = [] | ||||
| values = [] | values = [] | ||||
| for bookmark, node in pycompat.iteritems(bookmarks): | for bookmark, node in bookmarks.items(): | ||||
| args.append(b'(%s, %s, %s)') | args.append(b'(%s, %s, %s)') | ||||
| values.extend((bookmark, node, self.reponame)) | values.extend((bookmark, node, self.reponame)) | ||||
| args = b','.join(args) | args = b','.join(args) | ||||
| self.sqlcursor.execute( | self.sqlcursor.execute( | ||||
| b"INSERT INTO bookmarkstonode(bookmark, node, reponame) " | b"INSERT INTO bookmarkstonode(bookmark, node, reponame) " | ||||
| b"VALUES %s ON DUPLICATE KEY UPDATE node=VALUES(node)" % args, | b"VALUES %s ON DUPLICATE KEY UPDATE node=VALUES(node)" % args, | ||||
| params=values, | params=values, | ||||
| # hooks to record bookmark changes (both local and remote) | # hooks to record bookmark changes (both local and remote) | ||||
| def recordbookmarks(orig, store, fp): | def recordbookmarks(orig, store, fp): | ||||
| """Records all bookmark changes in the journal.""" | """Records all bookmark changes in the journal.""" | ||||
| repo = store._repo | repo = store._repo | ||||
| if util.safehasattr(repo, 'journal'): | if util.safehasattr(repo, 'journal'): | ||||
| oldmarks = bookmarks.bmstore(repo) | oldmarks = bookmarks.bmstore(repo) | ||||
| for mark, value in pycompat.iteritems(store): | for mark, value in store.items(): | ||||
| oldvalue = oldmarks.get(mark, repo.nullid) | oldvalue = oldmarks.get(mark, repo.nullid) | ||||
| if value != oldvalue: | if value != oldvalue: | ||||
| repo.journal.record(bookmarktype, mark, oldvalue, value) | repo.journal.record(bookmarktype, mark, oldvalue, value) | ||||
| return orig(store, fp) | return orig(store, fp) | ||||
| # shared repository support | # shared repository support | ||||
| def _readsharedfeatures(repo): | def _readsharedfeatures(repo): | ||||
| elif opts.get('default'): | elif opts.get('default'): | ||||
| if svn: | if svn: | ||||
| ui.status(_(b'\n\tconfiguration using default svn keywordset\n')) | ui.status(_(b'\n\tconfiguration using default svn keywordset\n')) | ||||
| else: | else: | ||||
| ui.status(_(b'\n\tconfiguration using default cvs keywordset\n')) | ui.status(_(b'\n\tconfiguration using default cvs keywordset\n')) | ||||
| kwmaps = _defaultkwmaps(ui) | kwmaps = _defaultkwmaps(ui) | ||||
| if uikwmaps: | if uikwmaps: | ||||
| ui.status(_(b'\tdisabling current template maps\n')) | ui.status(_(b'\tdisabling current template maps\n')) | ||||
| for k, v in pycompat.iteritems(kwmaps): | for k, v in kwmaps.items(): | ||||
| ui.setconfig(b'keywordmaps', k, v, b'keyword') | ui.setconfig(b'keywordmaps', k, v, b'keyword') | ||||
| else: | else: | ||||
| ui.status(_(b'\n\tconfiguration using current keyword template maps\n')) | ui.status(_(b'\n\tconfiguration using current keyword template maps\n')) | ||||
| if uikwmaps: | if uikwmaps: | ||||
| kwmaps = dict(uikwmaps) | kwmaps = dict(uikwmaps) | ||||
| else: | else: | ||||
| kwmaps = _defaultkwmaps(ui) | kwmaps = _defaultkwmaps(ui) | ||||
| uisetup(ui) | uisetup(ui) | ||||
| reposetup(ui, repo) | reposetup(ui, repo) | ||||
| ui.writenoi18n(b'[extensions]\nkeyword =\n') | ui.writenoi18n(b'[extensions]\nkeyword =\n') | ||||
| demoitems(b'keyword', ui.configitems(b'keyword')) | demoitems(b'keyword', ui.configitems(b'keyword')) | ||||
| demoitems(b'keywordset', ui.configitems(b'keywordset')) | demoitems(b'keywordset', ui.configitems(b'keywordset')) | ||||
| demoitems(b'keywordmaps', pycompat.iteritems(kwmaps)) | demoitems(b'keywordmaps', kwmaps.items()) | ||||
| keywords = b'$' + b'$\n$'.join(sorted(kwmaps.keys())) + b'$\n' | keywords = b'$' + b'$\n$'.join(sorted(kwmaps.keys())) + b'$\n' | ||||
| repo.wvfs.write(fn, keywords) | repo.wvfs.write(fn, keywords) | ||||
| repo[None].add([fn]) | repo[None].add([fn]) | ||||
| ui.note(_(b'\nkeywords written to %s:\n') % fn) | ui.note(_(b'\nkeywords written to %s:\n') % fn) | ||||
| ui.note(keywords) | ui.note(keywords) | ||||
| with repo.wlock(): | with repo.wlock(): | ||||
| repo.dirstate.setbranch(b'demobranch') | repo.dirstate.setbranch(b'demobranch') | ||||
| for name, cmd in ui.configitems(b'hooks'): | for name, cmd in ui.configitems(b'hooks'): | ||||
| return 0, False | return 0, False | ||||
| @eh.wrapfunction(copiesmod, b'pathcopies') | @eh.wrapfunction(copiesmod, b'pathcopies') | ||||
| def copiespathcopies(orig, ctx1, ctx2, match=None): | def copiespathcopies(orig, ctx1, ctx2, match=None): | ||||
| copies = orig(ctx1, ctx2, match=match) | copies = orig(ctx1, ctx2, match=match) | ||||
| updated = {} | updated = {} | ||||
| for k, v in pycompat.iteritems(copies): | for k, v in copies.items(): | ||||
| updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v | updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v | ||||
| return updated | return updated | ||||
| # Copy first changes the matchers to match standins instead of | # Copy first changes the matchers to match standins instead of | ||||
| # largefiles. Then it overrides util.copyfile in that function it | # largefiles. Then it overrides util.copyfile in that function it | ||||
| # checks if the destination largefile already exists. It also keeps a | # checks if the destination largefile already exists. It also keeps a | ||||
| b'size': re.compile(br'\A[0-9]+\Z'), | b'size': re.compile(br'\A[0-9]+\Z'), | ||||
| b'oid': re.compile(br'\Asha256:[0-9a-f]{64}\Z'), | b'oid': re.compile(br'\Asha256:[0-9a-f]{64}\Z'), | ||||
| b'version': re.compile(br'\A%s\Z' % stringutil.reescape(VERSION)), | b'version': re.compile(br'\A%s\Z' % stringutil.reescape(VERSION)), | ||||
| } | } | ||||
| def validate(self): | def validate(self): | ||||
| """raise InvalidPointer on error. return self if there is no error""" | """raise InvalidPointer on error. return self if there is no error""" | ||||
| requiredcount = 0 | requiredcount = 0 | ||||
| for k, v in pycompat.iteritems(self): | for k, v in self.items(): | ||||
| if k in self._requiredre: | if k in self._requiredre: | ||||
| if not self._requiredre[k].match(v): | if not self._requiredre[k].match(v): | ||||
| raise InvalidPointer( | raise InvalidPointer( | ||||
| _(b'unexpected lfs pointer value: %s=%s') | _(b'unexpected lfs pointer value: %s=%s') | ||||
| % (k, stringutil.pprint(v)) | % (k, stringutil.pprint(v)) | ||||
| ) | ) | ||||
| requiredcount += 1 | requiredcount += 1 | ||||
| elif not self._keyre.match(k): | elif not self._keyre.match(k): | ||||
| bundle2, | bundle2, | ||||
| changegroup, | changegroup, | ||||
| cmdutil, | cmdutil, | ||||
| context, | context, | ||||
| error, | error, | ||||
| exchange, | exchange, | ||||
| exthelper, | exthelper, | ||||
| localrepo, | localrepo, | ||||
| pycompat, | |||||
| revlog, | revlog, | ||||
| scmutil, | scmutil, | ||||
| util, | util, | ||||
| vfs as vfsmod, | vfs as vfsmod, | ||||
| wireprotov1server, | wireprotov1server, | ||||
| ) | ) | ||||
| from mercurial.upgrade_utils import ( | from mercurial.upgrade_utils import ( | ||||
| # be used for non-binary content. add a special entry for non-binary data. | # be used for non-binary content. add a special entry for non-binary data. | ||||
| # this will be used by filectx.isbinary(). | # this will be used by filectx.isbinary(). | ||||
| if not stringutil.binary(text): | if not stringutil.binary(text): | ||||
| # not hg filelog metadata (affecting commit hash), no "x-hg-" prefix | # not hg filelog metadata (affecting commit hash), no "x-hg-" prefix | ||||
| metadata[b'x-is-binary'] = b'0' | metadata[b'x-is-binary'] = b'0' | ||||
| # translate hg filelog metadata to lfs metadata with "x-hg-" prefix | # translate hg filelog metadata to lfs metadata with "x-hg-" prefix | ||||
| if hgmeta is not None: | if hgmeta is not None: | ||||
| for k, v in pycompat.iteritems(hgmeta): | for k, v in hgmeta.items(): | ||||
| metadata[b'x-hg-%s' % k] = v | metadata[b'x-hg-%s' % k] = v | ||||
| rawtext = metadata.serialize() | rawtext = metadata.serialize() | ||||
| return (rawtext, False) | return (rawtext, False) | ||||
| def _islfs(rlog, node=None, rev=None): | def _islfs(rlog, node=None, rev=None): | ||||
| if rev is None: | if rev is None: | ||||
| copies.setdefault(src, []).extend( | copies.setdefault(src, []).extend( | ||||
| copies.get(dst, []) | copies.get(dst, []) | ||||
| ) | ) | ||||
| if dst in a: | if dst in a: | ||||
| copies[src].append(dst) | copies[src].append(dst) | ||||
| # we can't copy a file created by the patch itself | # we can't copy a file created by the patch itself | ||||
| if dst in copies: | if dst in copies: | ||||
| del copies[dst] | del copies[dst] | ||||
| for src, dsts in pycompat.iteritems(copies): | for src, dsts in copies.items(): | ||||
| for dst in dsts: | for dst in dsts: | ||||
| repo.dirstate.copy(src, dst) | repo.dirstate.copy(src, dst) | ||||
| else: | else: | ||||
| for dst in a: | for dst in a: | ||||
| repo.dirstate.update_file( | repo.dirstate.update_file( | ||||
| dst, p1_tracked=False, wc_tracked=True | dst, p1_tracked=False, wc_tracked=True | ||||
| ) | ) | ||||
| # Drop useless copy information | # Drop useless copy information | ||||
| extensions.wrapcommand(commands.table, b'import', mqimport) | extensions.wrapcommand(commands.table, b'import', mqimport) | ||||
| cmdutil.summaryhooks.add(b'mq', summaryhook) | cmdutil.summaryhooks.add(b'mq', summaryhook) | ||||
| entry = extensions.wrapcommand(commands.table, b'init', mqinit) | entry = extensions.wrapcommand(commands.table, b'init', mqinit) | ||||
| entry[1].extend(mqopt) | entry[1].extend(mqopt) | ||||
| def dotable(cmdtable): | def dotable(cmdtable): | ||||
| for cmd, entry in pycompat.iteritems(cmdtable): | for cmd, entry in cmdtable.items(): | ||||
| cmd = cmdutil.parsealiases(cmd)[0] | cmd = cmdutil.parsealiases(cmd)[0] | ||||
| func = entry[0] | func = entry[0] | ||||
| if func.norepo: | if func.norepo: | ||||
| continue | continue | ||||
| entry = extensions.wrapcommand(cmdtable, cmd, mqcommand) | entry = extensions.wrapcommand(cmdtable, cmd, mqcommand) | ||||
| entry[1].extend(mqopt) | entry[1].extend(mqopt) | ||||
| dotable(commands.table) | dotable(commands.table) | ||||
| raise error.InputError(_(b'--rev requires a repository')) | raise error.InputError(_(b'--rev requires a repository')) | ||||
| if specs: | if specs: | ||||
| raise error.InputError(_(b'cannot specify both DREVSPEC and --rev')) | raise error.InputError(_(b'cannot specify both DREVSPEC and --rev')) | ||||
| drevmap = getdrevmap(repo, logcmdutil.revrange(repo, [revs])) | drevmap = getdrevmap(repo, logcmdutil.revrange(repo, [revs])) | ||||
| specs = [] | specs = [] | ||||
| unknown = [] | unknown = [] | ||||
| for r, d in pycompat.iteritems(drevmap): | for r, d in drevmap.items(): | ||||
| if d is None: | if d is None: | ||||
| unknown.append(repo[r]) | unknown.append(repo[r]) | ||||
| else: | else: | ||||
| specs.append(b'D%d' % d) | specs.append(b'D%d' % d) | ||||
| if unknown: | if unknown: | ||||
| raise error.InputError( | raise error.InputError( | ||||
| _(b'selected revisions without a Differential: %s') | _(b'selected revisions without a Differential: %s') | ||||
| % scmutil.nodesummaries(repo, unknown) | % scmutil.nodesummaries(repo, unknown) | ||||
| @show.showview(b'phabstatus', csettopic=b'work') | @show.showview(b'phabstatus', csettopic=b'work') | ||||
| def phabstatusshowview(ui, repo, displayer): | def phabstatusshowview(ui, repo, displayer): | ||||
| """Phabricator differiential status""" | """Phabricator differiential status""" | ||||
| revs = repo.revs('sort(_underway(), topo)') | revs = repo.revs('sort(_underway(), topo)') | ||||
| drevmap = getdrevmap(repo, revs) | drevmap = getdrevmap(repo, revs) | ||||
| unknownrevs, drevids, revsbydrevid = [], set(), {} | unknownrevs, drevids, revsbydrevid = [], set(), {} | ||||
| for rev, drevid in pycompat.iteritems(drevmap): | for rev, drevid in drevmap.items(): | ||||
| if drevid is not None: | if drevid is not None: | ||||
| drevids.add(drevid) | drevids.add(drevid) | ||||
| revsbydrevid.setdefault(drevid, set()).add(rev) | revsbydrevid.setdefault(drevid, set()).add(rev) | ||||
| else: | else: | ||||
| unknownrevs.append(rev) | unknownrevs.append(rev) | ||||
| drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)}) | drevs = callconduit(ui, b'differential.query', {b'ids': list(drevids)}) | ||||
| drevsbyrev = {} | drevsbyrev = {} | ||||
| # was "dest". we now write dest per src root below. | # was "dest". we now write dest per src root below. | ||||
| f.write(b'\n') | f.write(b'\n') | ||||
| f.write(repo[self.external].hex() + b'\n') | f.write(repo[self.external].hex() + b'\n') | ||||
| f.write(b'%d\n' % int(self.collapsef)) | f.write(b'%d\n' % int(self.collapsef)) | ||||
| f.write(b'%d\n' % int(self.keepf)) | f.write(b'%d\n' % int(self.keepf)) | ||||
| f.write(b'%d\n' % int(self.keepbranchesf)) | f.write(b'%d\n' % int(self.keepbranchesf)) | ||||
| f.write(b'%s\n' % (self.activebookmark or b'')) | f.write(b'%s\n' % (self.activebookmark or b'')) | ||||
| destmap = self.destmap | destmap = self.destmap | ||||
| for d, v in pycompat.iteritems(self.state): | for d, v in self.state.items(): | ||||
| oldrev = repo[d].hex() | oldrev = repo[d].hex() | ||||
| if v >= 0: | if v >= 0: | ||||
| newrev = repo[v].hex() | newrev = repo[v].hex() | ||||
| else: | else: | ||||
| newrev = b"%d" % v | newrev = b"%d" % v | ||||
| destnode = repo[destmap[d]].hex() | destnode = repo[destmap[d]].hex() | ||||
| f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode)) | f.write(b"%s:%s:%s\n" % (oldrev, newrev, destnode)) | ||||
| repo.ui.debug(b'rebase status stored\n') | repo.ui.debug(b'rebase status stored\n') | ||||
| # Store the state before we begin so users can run 'hg rebase --abort' | # Store the state before we begin so users can run 'hg rebase --abort' | ||||
| # if we fail before the transaction closes. | # if we fail before the transaction closes. | ||||
| self.storestatus() | self.storestatus() | ||||
| if tr: | if tr: | ||||
| # When using single transaction, store state when transaction | # When using single transaction, store state when transaction | ||||
| # commits. | # commits. | ||||
| self.storestatus(tr) | self.storestatus(tr) | ||||
| cands = [k for k, v in pycompat.iteritems(self.state) if v == revtodo] | cands = [k for k, v in self.state.items() if v == revtodo] | ||||
| p = repo.ui.makeprogress( | p = repo.ui.makeprogress( | ||||
| _(b"rebasing"), unit=_(b'changesets'), total=len(cands) | _(b"rebasing"), unit=_(b'changesets'), total=len(cands) | ||||
| ) | ) | ||||
| def progress(ctx): | def progress(ctx): | ||||
| p.increment(item=(b"%d:%s" % (ctx.rev(), ctx))) | p.increment(item=(b"%d:%s" % (ctx.rev(), ctx))) | ||||
| for subset in sortsource(self.destmap): | for subset in sortsource(self.destmap): | ||||
| bpbase = {} # {branchingpoint: [origbase]} | bpbase = {} # {branchingpoint: [origbase]} | ||||
| for b in base: # group bases by branching points | for b in base: # group bases by branching points | ||||
| bp = repo.revs(b'ancestor(%d, %d)', b, dest.rev()).first() | bp = repo.revs(b'ancestor(%d, %d)', b, dest.rev()).first() | ||||
| bpbase[bp] = bpbase.get(bp, []) + [b] | bpbase[bp] = bpbase.get(bp, []) + [b] | ||||
| if None in bpbase: | if None in bpbase: | ||||
| # emulate the old behavior, showing "nothing to rebase" (a better | # emulate the old behavior, showing "nothing to rebase" (a better | ||||
| # behavior may be abort with "cannot find branching point" error) | # behavior may be abort with "cannot find branching point" error) | ||||
| bpbase.clear() | bpbase.clear() | ||||
| for bp, bs in pycompat.iteritems(bpbase): # calculate roots | for bp, bs in bpbase.items(): # calculate roots | ||||
| roots += list(repo.revs(b'children(%d) & ancestors(%ld)', bp, bs)) | roots += list(repo.revs(b'children(%d) & ancestors(%ld)', bp, bs)) | ||||
| rebaseset = repo.revs(b'%ld::', roots) | rebaseset = repo.revs(b'%ld::', roots) | ||||
| if not rebaseset: | if not rebaseset: | ||||
| # transform to list because smartsets are not comparable to | # transform to list because smartsets are not comparable to | ||||
| # lists. This should be improved to honor laziness of | # lists. This should be improved to honor laziness of | ||||
| # smartset. | # smartset. | ||||
| replacements[(oldnode,)] = succs | replacements[(oldnode,)] = succs | ||||
| if collapsednodes: | if collapsednodes: | ||||
| replacements[tuple(collapsednodes)] = (collapsedas,) | replacements[tuple(collapsednodes)] = (collapsedas,) | ||||
| if fm: | if fm: | ||||
| hf = fm.hexfunc | hf = fm.hexfunc | ||||
| fl = fm.formatlist | fl = fm.formatlist | ||||
| fd = fm.formatdict | fd = fm.formatdict | ||||
| changes = {} | changes = {} | ||||
| for oldns, newn in pycompat.iteritems(replacements): | for oldns, newn in replacements.items(): | ||||
| for oldn in oldns: | for oldn in oldns: | ||||
| changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node') | changes[hf(oldn)] = fl([hf(n) for n in newn], name=b'node') | ||||
| 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) | ||||
| class releasenotessections(object): | class releasenotessections(object): | ||||
| def __init__(self, ui, repo=None): | def __init__(self, ui, repo=None): | ||||
| if repo: | if repo: | ||||
| sections = util.sortdict(DEFAULT_SECTIONS) | sections = util.sortdict(DEFAULT_SECTIONS) | ||||
| custom_sections = getcustomadmonitions(repo) | custom_sections = getcustomadmonitions(repo) | ||||
| if custom_sections: | if custom_sections: | ||||
| sections.update(custom_sections) | sections.update(custom_sections) | ||||
| self._sections = list(pycompat.iteritems(sections)) | self._sections = list(sections.items()) | ||||
| else: | else: | ||||
| self._sections = list(DEFAULT_SECTIONS) | self._sections = list(DEFAULT_SECTIONS) | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return iter(self._sections) | return iter(self._sections) | ||||
| def names(self): | def names(self): | ||||
| return [t[0] for t in self._sections] | return [t[0] for t in self._sections] | ||||
| name+node keys and not namehash+node keys. | name+node keys and not namehash+node keys. | ||||
| """ | """ | ||||
| existing = {} | existing = {} | ||||
| for filenamehash, node in self._listkeys(): | for filenamehash, node in self._listkeys(): | ||||
| existing.setdefault(filenamehash, []).append(node) | existing.setdefault(filenamehash, []).append(node) | ||||
| filenamemap = self._resolvefilenames(existing.keys()) | filenamemap = self._resolvefilenames(existing.keys()) | ||||
| for filename, sha in pycompat.iteritems(filenamemap): | for filename, sha in filenamemap.items(): | ||||
| yield (filename, existing[sha]) | yield (filename, existing[sha]) | ||||
| def _resolvefilenames(self, hashes): | def _resolvefilenames(self, hashes): | ||||
| """Given a list of filename hashes that are present in the | """Given a list of filename hashes that are present in the | ||||
| remotefilelog store, return a mapping from filename->hash. | remotefilelog store, return a mapping from filename->hash. | ||||
| This is useful when converting remotefilelog blobs into other storage | This is useful when converting remotefilelog blobs into other storage | ||||
| formats. | formats. | ||||
| size = len(rawdata) | size = len(rawdata) | ||||
| self.entries[node] = (deltabasenode, offset, size) | self.entries[node] = (deltabasenode, offset, size) | ||||
| self.writeraw(rawdata) | self.writeraw(rawdata) | ||||
| def createindex(self, nodelocations, indexoffset): | def createindex(self, nodelocations, indexoffset): | ||||
| entries = sorted( | entries = sorted( | ||||
| (n, db, o, s) for n, (db, o, s) in pycompat.iteritems(self.entries) | (n, db, o, s) for n, (db, o, s) in self.entries.items() | ||||
| ) | ) | ||||
| rawindex = b'' | rawindex = b'' | ||||
| fmt = self.INDEXFORMAT | fmt = self.INDEXFORMAT | ||||
| for node, deltabase, offset, size in entries: | for node, deltabase, offset, size in entries: | ||||
| if deltabase == sha1nodeconstants.nullid: | if deltabase == sha1nodeconstants.nullid: | ||||
| deltabaselocation = FULLTEXTINDEXMARK | deltabaselocation = FULLTEXTINDEXMARK | ||||
| else: | else: | ||||
| def createindex(self, nodelocations, indexoffset): | def createindex(self, nodelocations, indexoffset): | ||||
| fileindexformat = self.INDEXFORMAT | fileindexformat = self.INDEXFORMAT | ||||
| fileindexlength = self.INDEXENTRYLENGTH | fileindexlength = self.INDEXENTRYLENGTH | ||||
| nodeindexformat = self.NODEINDEXFORMAT | nodeindexformat = self.NODEINDEXFORMAT | ||||
| nodeindexlength = self.NODEINDEXENTRYLENGTH | nodeindexlength = self.NODEINDEXENTRYLENGTH | ||||
| files = ( | files = ( | ||||
| (hashutil.sha1(filename).digest(), filename, offset, size) | (hashutil.sha1(filename).digest(), filename, offset, size) | ||||
| for filename, (offset, size) in pycompat.iteritems(self.files) | for filename, (offset, size) in self.files.items() | ||||
| ) | ) | ||||
| files = sorted(files) | files = sorted(files) | ||||
| # node index is after file index size, file index, and node index size | # node index is after file index size, file index, and node index size | ||||
| indexlensize = struct.calcsize(b'!Q') | indexlensize = struct.calcsize(b'!Q') | ||||
| nodeindexoffset = ( | nodeindexoffset = ( | ||||
| indexoffset | indexoffset | ||||
| + indexlensize | + indexlensize | ||||
| nodeindexsize, | nodeindexsize, | ||||
| ) | ) | ||||
| # Node index | # Node index | ||||
| nodeindexentries.append( | nodeindexentries.append( | ||||
| struct.pack(constants.FILENAMESTRUCT, len(filename)) + filename | struct.pack(constants.FILENAMESTRUCT, len(filename)) + filename | ||||
| ) | ) | ||||
| nodeindexoffset += constants.FILENAMESIZE + len(filename) | nodeindexoffset += constants.FILENAMESIZE + len(filename) | ||||
| for node, location in sorted(pycompat.iteritems(nodelocations)): | for node, location in sorted(nodelocations.items()): | ||||
| nodeindexentries.append( | nodeindexentries.append( | ||||
| struct.pack(nodeindexformat, node, location) | struct.pack(nodeindexformat, node, location) | ||||
| ) | ) | ||||
| nodecount += 1 | nodecount += 1 | ||||
| nodeindexoffset += len(nodelocations) * nodeindexlength | nodeindexoffset += len(nodelocations) * nodeindexlength | ||||
| fileindexentries.append(rawentry) | fileindexentries.append(rawentry) | ||||
| nodecountraw = struct.pack(b'!Q', nodecount) | nodecountraw = struct.pack(b'!Q', nodecount) | ||||
| return ( | return ( | ||||
| b''.join(fileindexentries) | b''.join(fileindexentries) | ||||
| + nodecountraw | + nodecountraw | ||||
| + b''.join(nodeindexentries) | + b''.join(nodeindexentries) | ||||
| ) | ) | ||||
| import os | import os | ||||
| from mercurial.node import bin | from mercurial.node import bin | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial import ( | from mercurial import ( | ||||
| ancestor, | ancestor, | ||||
| error, | error, | ||||
| mdiff, | mdiff, | ||||
| pycompat, | |||||
| revlog, | revlog, | ||||
| ) | ) | ||||
| from mercurial.utils import storageutil | from mercurial.utils import storageutil | ||||
| from mercurial.revlogutils import flagutil | from mercurial.revlogutils import flagutil | ||||
| from . import ( | from . import ( | ||||
| constants, | constants, | ||||
| fileserverclient, | fileserverclient, | ||||
| def ancestormap(self, node): | def ancestormap(self, node): | ||||
| return self.repo.metadatastore.getancestors(self.filename, node) | return self.repo.metadatastore.getancestors(self.filename, node) | ||||
| def ancestor(self, a, b): | def ancestor(self, a, b): | ||||
| if a == self.repo.nullid or b == self.repo.nullid: | if a == self.repo.nullid or b == self.repo.nullid: | ||||
| return self.repo.nullid | return self.repo.nullid | ||||
| revmap, parentfunc = self._buildrevgraph(a, b) | revmap, parentfunc = self._buildrevgraph(a, b) | ||||
| nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} | nodemap = {v: k for (k, v) in revmap.items()} | ||||
| ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b]) | ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b]) | ||||
| if ancs: | if ancs: | ||||
| # choose a consistent winner when there's a tie | # choose a consistent winner when there's a tie | ||||
| return min(map(nodemap.__getitem__, ancs)) | return min(map(nodemap.__getitem__, ancs)) | ||||
| return self.repo.nullid | return self.repo.nullid | ||||
| def commonancestorsheads(self, a, b): | def commonancestorsheads(self, a, b): | ||||
| """calculate all the heads of the common ancestors of nodes a and b""" | """calculate all the heads of the common ancestors of nodes a and b""" | ||||
| if a == self.repo.nullid or b == self.repo.nullid: | if a == self.repo.nullid or b == self.repo.nullid: | ||||
| return self.repo.nullid | return self.repo.nullid | ||||
| revmap, parentfunc = self._buildrevgraph(a, b) | revmap, parentfunc = self._buildrevgraph(a, b) | ||||
| nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} | nodemap = {v: k for (k, v) in revmap.items()} | ||||
| ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b]) | ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b]) | ||||
| return map(nodemap.__getitem__, ancs) | return map(nodemap.__getitem__, ancs) | ||||
| def _buildrevgraph(self, a, b): | def _buildrevgraph(self, a, b): | ||||
| """Builds a numeric revision graph for the given two nodes. | """Builds a numeric revision graph for the given two nodes. | ||||
| Returns a node->rev map and a rev->[revs] parent function. | Returns a node->rev map and a rev->[revs] parent function. | ||||
| """ | """ | ||||
| amap = self.ancestormap(a) | amap = self.ancestormap(a) | ||||
| bmap = self.ancestormap(b) | bmap = self.ancestormap(b) | ||||
| # Union the two maps | # Union the two maps | ||||
| parentsmap = collections.defaultdict(list) | parentsmap = collections.defaultdict(list) | ||||
| allparents = set() | allparents = set() | ||||
| for mapping in (amap, bmap): | for mapping in (amap, bmap): | ||||
| for node, pdata in pycompat.iteritems(mapping): | for node, pdata in mapping.items(): | ||||
| parents = parentsmap[node] | parents = parentsmap[node] | ||||
| p1, p2, linknode, copyfrom = pdata | p1, p2, linknode, copyfrom = pdata | ||||
| # Don't follow renames (copyfrom). | # Don't follow renames (copyfrom). | ||||
| # remotefilectx.ancestor does that. | # remotefilectx.ancestor does that. | ||||
| if p1 != self.repo.nullid and not copyfrom: | if p1 != self.repo.nullid and not copyfrom: | ||||
| parents.append(p1) | parents.append(p1) | ||||
| allparents.add(p1) | allparents.add(p1) | ||||
| if p2 != self.repo.nullid: | if p2 != self.repo.nullid: | ||||
| from mercurial.pycompat import open | from mercurial.pycompat import open | ||||
| from mercurial import ( | from mercurial import ( | ||||
| changegroup, | changegroup, | ||||
| changelog, | changelog, | ||||
| context, | context, | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| match, | match, | ||||
| pycompat, | |||||
| scmutil, | scmutil, | ||||
| store, | store, | ||||
| streamclone, | streamclone, | ||||
| util, | util, | ||||
| wireprotoserver, | wireprotoserver, | ||||
| wireprototypes, | wireprototypes, | ||||
| wireprotov1server, | wireprotov1server, | ||||
| ) | ) | ||||
| return | return | ||||
| neededfiles = set() | neededfiles = set() | ||||
| heads = repo.revs(b"heads(tip~25000:) - null") | heads = repo.revs(b"heads(tip~25000:) - null") | ||||
| cachepath = repo.vfs.join(b"remotefilelogcache") | cachepath = repo.vfs.join(b"remotefilelogcache") | ||||
| for head in heads: | for head in heads: | ||||
| mf = repo[head].manifest() | mf = repo[head].manifest() | ||||
| for filename, filenode in pycompat.iteritems(mf): | for filename, filenode in mf.items(): | ||||
| filecachepath = os.path.join(cachepath, filename, hex(filenode)) | filecachepath = os.path.join(cachepath, filename, hex(filenode)) | ||||
| neededfiles.add(filecachepath) | neededfiles.add(filecachepath) | ||||
| # delete unneeded older files | # delete unneeded older files | ||||
| days = repo.ui.configint(b"remotefilelog", b"serverexpiration") | days = repo.ui.configint(b"remotefilelog", b"serverexpiration") | ||||
| expiration = time.time() - (days * 24 * 60 * 60) | expiration = time.time() - (days * 24 * 60 * 60) | ||||
| progress = ui.makeprogress(_(b"removing old server cache"), unit=b"files") | progress = ui.makeprogress(_(b"removing old server cache"), unit=b"files") | ||||
| m = repo[r].manifest() | m = repo[r].manifest() | ||||
| lastmanifest = repo[r].manifest() | lastmanifest = repo[r].manifest() | ||||
| processed.add(r) | processed.add(r) | ||||
| # populate keepkeys with keys from the current manifest | # populate keepkeys with keys from the current manifest | ||||
| if type(m) is dict: | if type(m) is dict: | ||||
| # m is a result of diff of two manifests and is a dictionary that | # m is a result of diff of two manifests and is a dictionary that | ||||
| # maps filename to ((newnode, newflag), (oldnode, oldflag)) tuple | # maps filename to ((newnode, newflag), (oldnode, oldflag)) tuple | ||||
| for filename, diff in pycompat.iteritems(m): | for filename, diff in m.items(): | ||||
| if diff[0][0] is not None: | if diff[0][0] is not None: | ||||
| keepkeys.add(keyfn(filename, diff[0][0])) | keepkeys.add(keyfn(filename, diff[0][0])) | ||||
| else: | else: | ||||
| # m is a manifest object | # m is a manifest object | ||||
| for filename, filenode in pycompat.iteritems(m): | for filename, filenode in m.items(): | ||||
| keepkeys.add(keyfn(filename, filenode)) | keepkeys.add(keyfn(filename, filenode)) | ||||
| return keepkeys | return keepkeys | ||||
| class repacker(object): | class repacker(object): | ||||
| """Class for orchestrating the repack of data and history information into a | """Class for orchestrating the repack of data and history information into a | ||||
| new format. | new format. | ||||
| for entry in pycompat.itervalues(ledger.entries): | for entry in pycompat.itervalues(ledger.entries): | ||||
| if entry.datasource: | if entry.datasource: | ||||
| byfile.setdefault(entry.filename, {})[entry.node] = entry | byfile.setdefault(entry.filename, {})[entry.node] = entry | ||||
| count = 0 | count = 0 | ||||
| repackprogress = ui.makeprogress( | repackprogress = ui.makeprogress( | ||||
| _(b"repacking data"), unit=self.unit, total=len(byfile) | _(b"repacking data"), unit=self.unit, total=len(byfile) | ||||
| ) | ) | ||||
| for filename, entries in sorted(pycompat.iteritems(byfile)): | for filename, entries in sorted(byfile.items()): | ||||
| repackprogress.update(count) | repackprogress.update(count) | ||||
| ancestors = {} | ancestors = {} | ||||
| nodes = list(node for node in entries) | nodes = list(node for node in entries) | ||||
| nohistory = [] | nohistory = [] | ||||
| buildprogress = ui.makeprogress( | buildprogress = ui.makeprogress( | ||||
| _(b"building history"), unit=b'nodes', total=len(nodes) | _(b"building history"), unit=b'nodes', total=len(nodes) | ||||
| ) | ) | ||||
| byfile = {} | byfile = {} | ||||
| for entry in pycompat.itervalues(ledger.entries): | for entry in pycompat.itervalues(ledger.entries): | ||||
| if entry.historysource: | if entry.historysource: | ||||
| byfile.setdefault(entry.filename, {})[entry.node] = entry | byfile.setdefault(entry.filename, {})[entry.node] = entry | ||||
| progress = ui.makeprogress( | progress = ui.makeprogress( | ||||
| _(b"repacking history"), unit=self.unit, total=len(byfile) | _(b"repacking history"), unit=self.unit, total=len(byfile) | ||||
| ) | ) | ||||
| for filename, entries in sorted(pycompat.iteritems(byfile)): | for filename, entries in sorted(byfile.items()): | ||||
| ancestors = {} | ancestors = {} | ||||
| nodes = list(node for node in entries) | nodes = list(node for node in entries) | ||||
| for node in nodes: | for node in nodes: | ||||
| if node in ancestors: | if node in ancestors: | ||||
| continue | continue | ||||
| ancestors.update( | ancestors.update( | ||||
| self.history.getancestors(filename, node, known=ancestors) | self.history.getancestors(filename, node, known=ancestors) | ||||
| # shallowrepo.py - shallow repository that uses remote filelogs | # shallowrepo.py - shallow repository that uses remote filelogs | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import hex, nullrev | from mercurial.node import hex, nullrev | ||||
| from mercurial import ( | from mercurial import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| localrepo, | localrepo, | ||||
| match, | match, | ||||
| pycompat, | |||||
| scmutil, | scmutil, | ||||
| sparse, | sparse, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from mercurial.utils import procutil | from mercurial.utils import procutil | ||||
| from . import ( | from . import ( | ||||
| connectionpool, | connectionpool, | ||||
| constants, | constants, | ||||
| base = serverbase[0] | base = serverbase[0] | ||||
| else: | else: | ||||
| localrevs = repo | localrevs = repo | ||||
| mfl = repo.manifestlog | mfl = repo.manifestlog | ||||
| mfrevlog = mfl.getstorage(b'') | mfrevlog = mfl.getstorage(b'') | ||||
| if base is not None: | if base is not None: | ||||
| mfdict = mfl[repo[base].manifestnode()].read() | mfdict = mfl[repo[base].manifestnode()].read() | ||||
| skip = set(pycompat.iteritems(mfdict)) | skip = set(mfdict.items()) | ||||
| else: | else: | ||||
| skip = set() | skip = set() | ||||
| # Copy the skip set to start large and avoid constant resizing, | # Copy the skip set to start large and avoid constant resizing, | ||||
| # and since it's likely to be very similar to the prefetch set. | # and since it's likely to be very similar to the prefetch set. | ||||
| files = skip.copy() | files = skip.copy() | ||||
| serverfiles = skip.copy() | serverfiles = skip.copy() | ||||
| visited = set() | visited = set() | ||||
| # Decompressing manifests is expensive. | # Decompressing manifests is expensive. | ||||
| # When possible, only read the deltas. | # When possible, only read the deltas. | ||||
| p1, p2 = mfrevlog.parentrevs(mfrev) | p1, p2 = mfrevlog.parentrevs(mfrev) | ||||
| if p1 in visited and p2 in visited: | if p1 in visited and p2 in visited: | ||||
| mfdict = mfl[mfnode].readfast() | mfdict = mfl[mfnode].readfast() | ||||
| else: | else: | ||||
| mfdict = mfl[mfnode].read() | mfdict = mfl[mfnode].read() | ||||
| diff = pycompat.iteritems(mfdict) | diff = mfdict.items() | ||||
| if pats: | if pats: | ||||
| diff = (pf for pf in diff if m(pf[0])) | diff = (pf for pf in diff if m(pf[0])) | ||||
| if sparsematch: | if sparsematch: | ||||
| diff = (pf for pf in diff if sparsematch(pf[0])) | diff = (pf for pf in diff if sparsematch(pf[0])) | ||||
| if rev not in localrevs: | if rev not in localrevs: | ||||
| serverfiles.update(diff) | serverfiles.update(diff) | ||||
| else: | else: | ||||
| files.update(diff) | files.update(diff) | ||||
| def sumdicts(*dicts): | def sumdicts(*dicts): | ||||
| """Adds all the values of *dicts together into one dictionary. This assumes | """Adds all the values of *dicts together into one dictionary. This assumes | ||||
| the values in *dicts are all summable. | the values in *dicts are all summable. | ||||
| e.g. [{'a': 4', 'b': 2}, {'b': 3, 'c': 1}] -> {'a': 4, 'b': 5, 'c': 1} | e.g. [{'a': 4', 'b': 2}, {'b': 3, 'c': 1}] -> {'a': 4, 'b': 5, 'c': 1} | ||||
| """ | """ | ||||
| result = collections.defaultdict(lambda: 0) | result = collections.defaultdict(lambda: 0) | ||||
| for dict in dicts: | for dict in dicts: | ||||
| for k, v in pycompat.iteritems(dict): | for k, v in dict.items(): | ||||
| result[k] += v | result[k] += v | ||||
| return result | return result | ||||
| def prefixkeys(dict, prefix): | def prefixkeys(dict, prefix): | ||||
| """Returns ``dict`` with ``prefix`` prepended to all its keys.""" | """Returns ``dict`` with ``prefix`` prepended to all its keys.""" | ||||
| result = {} | result = {} | ||||
| for k, v in pycompat.iteritems(dict): | for k, v in dict.items(): | ||||
| result[prefix + k] = v | result[prefix + k] = v | ||||
| return result | return result | ||||
| def reportpackmetrics(ui, prefix, *stores): | def reportpackmetrics(ui, prefix, *stores): | ||||
| dicts = [s.getmetrics() for s in stores] | dicts = [s.getmetrics() for s in stores] | ||||
| dict = prefixkeys(sumdicts(*dicts), prefix + b'_') | dict = prefixkeys(sumdicts(*dicts), prefix + b'_') | ||||
| ui.log(prefix + b"_packsizes", b"\n", **pycompat.strkwargs(dict)) | ui.log(prefix + b"_packsizes", b"\n", **pycompat.strkwargs(dict)) | ||||
| def parsepackmeta(metabuf): | def parsepackmeta(metabuf): | ||||
| """like _parsepackmeta, but convert fields to desired types automatically. | """like _parsepackmeta, but convert fields to desired types automatically. | ||||
| This means, METAKEYFLAG and METAKEYSIZE fields will be converted to | This means, METAKEYFLAG and METAKEYSIZE fields will be converted to | ||||
| integers. | integers. | ||||
| """ | """ | ||||
| metadict = _parsepackmeta(metabuf) | metadict = _parsepackmeta(metabuf) | ||||
| for k, v in pycompat.iteritems(metadict): | for k, v in metadict.items(): | ||||
| if k in _metaitemtypes and int in _metaitemtypes[k]: | if k in _metaitemtypes and int in _metaitemtypes[k]: | ||||
| metadict[k] = bin2int(v) | metadict[k] = bin2int(v) | ||||
| return metadict | return metadict | ||||
| def int2bin(n): | def int2bin(n): | ||||
| """convert a non-negative integer to raw binary buffer""" | """convert a non-negative integer to raw binary buffer""" | ||||
| buf = bytearray() | buf = bytearray() | ||||
| return self.potentialentries.keys() | return self.potentialentries.keys() | ||||
| def iteritems(self): | def iteritems(self): | ||||
| """Iterate over (name, node) tuples""" | """Iterate over (name, node) tuples""" | ||||
| if not self.loaded: | if not self.loaded: | ||||
| self._load() | self._load() | ||||
| for k, vtup in pycompat.iteritems(self.potentialentries): | for k, vtup in self.potentialentries.items(): | ||||
| yield (k, [bin(vtup[0])]) | yield (k, [bin(vtup[0])]) | ||||
| items = iteritems | items = iteritems | ||||
| class remotenames(object): | class remotenames(object): | ||||
| """ | """ | ||||
| This class encapsulates all the remotenames state. It also contains | This class encapsulates all the remotenames state. It also contains | ||||
| def bmarktonodes(self): | def bmarktonodes(self): | ||||
| return self.bookmarks | return self.bookmarks | ||||
| def nodetobmarks(self): | def nodetobmarks(self): | ||||
| if not self._nodetobmarks: | if not self._nodetobmarks: | ||||
| bmarktonodes = self.bmarktonodes() | bmarktonodes = self.bmarktonodes() | ||||
| self._nodetobmarks = {} | self._nodetobmarks = {} | ||||
| for name, node in pycompat.iteritems(bmarktonodes): | for name, node in bmarktonodes.items(): | ||||
| self._nodetobmarks.setdefault(node[0], []).append(name) | self._nodetobmarks.setdefault(node[0], []).append(name) | ||||
| return self._nodetobmarks | return self._nodetobmarks | ||||
| def branchtonodes(self): | def branchtonodes(self): | ||||
| return self.branches | return self.branches | ||||
| def nodetobranch(self): | def nodetobranch(self): | ||||
| if not self._nodetobranch: | if not self._nodetobranch: | ||||
| branchtonodes = self.branchtonodes() | branchtonodes = self.branchtonodes() | ||||
| self._nodetobranch = {} | self._nodetobranch = {} | ||||
| for name, nodes in pycompat.iteritems(branchtonodes): | for name, nodes in branchtonodes.items(): | ||||
| for node in nodes: | for node in nodes: | ||||
| self._nodetobranch.setdefault(node, []).append(name) | self._nodetobranch.setdefault(node, []).append(name) | ||||
| return self._nodetobranch | return self._nodetobranch | ||||
| def hoisttonodes(self, hoist): | def hoisttonodes(self, hoist): | ||||
| if not self._hoisttonodes: | if not self._hoisttonodes: | ||||
| marktonodes = self.bmarktonodes() | marktonodes = self.bmarktonodes() | ||||
| self._hoisttonodes = {} | self._hoisttonodes = {} | ||||
| hoist += b'/' | hoist += b'/' | ||||
| for name, node in pycompat.iteritems(marktonodes): | for name, node in marktonodes.items(): | ||||
| if name.startswith(hoist): | if name.startswith(hoist): | ||||
| name = name[len(hoist) :] | name = name[len(hoist) :] | ||||
| self._hoisttonodes[name] = node | self._hoisttonodes[name] = node | ||||
| return self._hoisttonodes | return self._hoisttonodes | ||||
| def nodetohoists(self, hoist): | def nodetohoists(self, hoist): | ||||
| if not self._nodetohoists: | if not self._nodetohoists: | ||||
| marktonodes = self.bmarktonodes() | marktonodes = self.bmarktonodes() | ||||
| self._nodetohoists = {} | self._nodetohoists = {} | ||||
| hoist += b'/' | hoist += b'/' | ||||
| for name, node in pycompat.iteritems(marktonodes): | for name, node in marktonodes.items(): | ||||
| if name.startswith(hoist): | if name.startswith(hoist): | ||||
| name = name[len(hoist) :] | name = name[len(hoist) :] | ||||
| self._nodetohoists.setdefault(node[0], []).append(name) | self._nodetohoists.setdefault(node[0], []).append(name) | ||||
| return self._nodetohoists | return self._nodetohoists | ||||
| def wrapprintbookmarks(orig, ui, repo, fm, bmarks): | def wrapprintbookmarks(orig, ui, repo, fm, bmarks): | ||||
| if b'remotebookmarks' not in repo.names: | if b'remotebookmarks' not in repo.names: | ||||
| # return the p1 so that we don't create an obsmarker later | # return the p1 so that we don't create an obsmarker later | ||||
| if not keepcommit: | if not keepcommit: | ||||
| return ctx.p1().node() | return ctx.p1().node() | ||||
| files = initialfiles - exclude | files = initialfiles - exclude | ||||
| # Filter copies | # Filter copies | ||||
| copied = copiesmod.pathcopies(base, ctx) | copied = copiesmod.pathcopies(base, ctx) | ||||
| copied = { | copied = {dst: src for dst, src in copied.items() if dst in files} | ||||
| dst: src for dst, src in pycompat.iteritems(copied) if dst in files | |||||
| } | |||||
| def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()): | def filectxfn(repo, memctx, path, contentctx=ctx, redirect=()): | ||||
| if path not in contentctx: | if path not in contentctx: | ||||
| return None | return None | ||||
| fctx = contentctx[path] | fctx = contentctx[path] | ||||
| mctx = context.memfilectx( | mctx = context.memfilectx( | ||||
| repo, | repo, | ||||
| memctx, | memctx, | ||||
| def forbidcr(ui, repo, hooktype, node, **kwargs): | def forbidcr(ui, repo, hooktype, node, **kwargs): | ||||
| return forbidnewline(ui, repo, hooktype, node, b'\r', **kwargs) | return forbidnewline(ui, repo, hooktype, node, b'\r', **kwargs) | ||||
| def reposetup(ui, repo): | def reposetup(ui, repo): | ||||
| if not repo.local(): | if not repo.local(): | ||||
| return | return | ||||
| for name, fn in pycompat.iteritems(_filters): | for name, fn in _filters.items(): | ||||
| repo.adddatafilter(name, fn) | repo.adddatafilter(name, fn) | ||||
| def wrap_revert(orig, repo, ctx, names, uipathfn, actions, *args, **kwargs): | def wrap_revert(orig, repo, ctx, names, uipathfn, actions, *args, **kwargs): | ||||
| # reset dirstate cache for file we touch | # reset dirstate cache for file we touch | ||||
| ds = repo.dirstate | ds = repo.dirstate | ||||
| with ds.parentchange(): | with ds.parentchange(): | ||||
| for filename in actions[b'revert'][0]: | for filename in actions[b'revert'][0]: | ||||
| b'tbz2': [b'.tbz2', b'.tar.bz2'], | b'tbz2': [b'.tbz2', b'.tar.bz2'], | ||||
| b'tgz': [b'.tgz', b'.tar.gz'], | b'tgz': [b'.tgz', b'.tar.gz'], | ||||
| b'zip': [b'.zip'], | b'zip': [b'.zip'], | ||||
| b'txz': [b'.txz', b'.tar.xz'], | b'txz': [b'.txz', b'.tar.xz'], | ||||
| } | } | ||||
| def guesskind(dest): | def guesskind(dest): | ||||
| for kind, extensions in pycompat.iteritems(exts): | for kind, extensions in exts.items(): | ||||
| if any(dest.endswith(ext) for ext in extensions): | if any(dest.endswith(ext) for ext in extensions): | ||||
| return kind | return kind | ||||
| return None | return None | ||||
| def _rootctx(repo): | def _rootctx(repo): | ||||
| # repo[0] may be hidden | # repo[0] may be hidden | ||||
| for rev in repo: | for rev in repo: | ||||
| def __len__(self): | def __len__(self): | ||||
| return len(self._refmap) | return len(self._refmap) | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return iter(self._refmap) | return iter(self._refmap) | ||||
| def iteritems(self): | def iteritems(self): | ||||
| return pycompat.iteritems(self._refmap) | return self._refmap.items() | ||||
| def items(self): | def items(self): | ||||
| return self._refmap.items() | return self._refmap.items() | ||||
| # TODO: maybe rename to allnames()? | # TODO: maybe rename to allnames()? | ||||
| def keys(self): | def keys(self): | ||||
| return self._refmap.keys() | return self._refmap.keys() | ||||
| b'bookmarks.current', b'w', atomictemp=True, checkambig=True | b'bookmarks.current', b'w', atomictemp=True, checkambig=True | ||||
| ) as f: | ) as f: | ||||
| f.write(encoding.fromlocal(self._active)) | f.write(encoding.fromlocal(self._active)) | ||||
| else: | else: | ||||
| self._repo.vfs.tryunlink(b'bookmarks.current') | self._repo.vfs.tryunlink(b'bookmarks.current') | ||||
| self._aclean = True | self._aclean = True | ||||
| def _write(self, fp): | def _write(self, fp): | ||||
| for name, node in sorted(pycompat.iteritems(self._refmap)): | for name, node in sorted(self._refmap.items()): | ||||
| fp.write(b"%s %s\n" % (hex(node), encoding.fromlocal(name))) | fp.write(b"%s %s\n" % (hex(node), encoding.fromlocal(name))) | ||||
| self._clean = True | self._clean = True | ||||
| self._repo.invalidatevolatilesets() | self._repo.invalidatevolatilesets() | ||||
| def expandname(self, bname): | def expandname(self, bname): | ||||
| if bname == b'.': | if bname == b'.': | ||||
| if self.active: | if self.active: | ||||
| return self.active | return self.active | ||||
| only one entry. | only one entry. | ||||
| """ | """ | ||||
| if not repo._activebookmark: | if not repo._activebookmark: | ||||
| raise ValueError( | raise ValueError( | ||||
| b'headsforactive() only makes sense with an active bookmark' | b'headsforactive() only makes sense with an active bookmark' | ||||
| ) | ) | ||||
| name = repo._activebookmark.split(b'@', 1)[0] | name = repo._activebookmark.split(b'@', 1)[0] | ||||
| heads = [] | heads = [] | ||||
| for mark, n in pycompat.iteritems(repo._bookmarks): | for mark, n in repo._bookmarks.items(): | ||||
| if mark.split(b'@', 1)[0] == name: | if mark.split(b'@', 1)[0] == name: | ||||
| heads.append(n) | heads.append(n) | ||||
| return heads | return heads | ||||
| def calculateupdate(ui, repo): | def calculateupdate(ui, repo): | ||||
| """Return a tuple (activemark, movemarkfrom) indicating the active bookmark | """Return a tuple (activemark, movemarkfrom) indicating the active bookmark | ||||
| and where to move the active bookmark from, if needed.""" | and where to move the active bookmark from, if needed.""" | ||||
| def listbinbookmarks(repo): | def listbinbookmarks(repo): | ||||
| # We may try to list bookmarks on a repo type that does not | # We may try to list bookmarks on a repo type that does not | ||||
| # support it (e.g., statichttprepository). | # support it (e.g., statichttprepository). | ||||
| marks = getattr(repo, '_bookmarks', {}) | marks = getattr(repo, '_bookmarks', {}) | ||||
| hasnode = repo.changelog.hasnode | hasnode = repo.changelog.hasnode | ||||
| for k, v in pycompat.iteritems(marks): | for k, v in marks.items(): | ||||
| # don't expose local divergent bookmarks | # don't expose local divergent bookmarks | ||||
| if hasnode(v) and not isdivergent(k): | if hasnode(v) and not isdivergent(k): | ||||
| yield k, v | yield k, v | ||||
| def listbookmarks(repo): | def listbookmarks(repo): | ||||
| d = {} | d = {} | ||||
| for book, node in listbinbookmarks(repo): | for book, node in listbinbookmarks(repo): | ||||
| return books | return books | ||||
| def mirroring_remote(ui, repo, remotemarks): | def mirroring_remote(ui, repo, remotemarks): | ||||
| """computes the bookmark changes that set the local bookmarks to | """computes the bookmark changes that set the local bookmarks to | ||||
| remotemarks""" | remotemarks""" | ||||
| changed = [] | changed = [] | ||||
| localmarks = repo._bookmarks | localmarks = repo._bookmarks | ||||
| for (b, id) in pycompat.iteritems(remotemarks): | for (b, id) in remotemarks.items(): | ||||
| if id != localmarks.get(b, None) and id in repo: | if id != localmarks.get(b, None) and id in repo: | ||||
| changed.append((b, id, ui.debug, _(b"updating bookmark %s\n") % b)) | changed.append((b, id, ui.debug, _(b"updating bookmark %s\n") % b)) | ||||
| for b in localmarks: | for b in localmarks: | ||||
| if b not in remotemarks: | if b not in remotemarks: | ||||
| changed.append( | changed.append( | ||||
| (b, None, ui.debug, _(b"removing bookmark %s\n") % b) | (b, None, ui.debug, _(b"removing bookmark %s\n") % b) | ||||
| ) | ) | ||||
| return changed | return changed | ||||
| """private method to print bookmarks | """private method to print bookmarks | ||||
| Provides a way for extensions to control how bookmarks are printed (e.g. | Provides a way for extensions to control how bookmarks are printed (e.g. | ||||
| prepend or postpend names) | prepend or postpend names) | ||||
| """ | """ | ||||
| hexfn = fm.hexfunc | hexfn = fm.hexfunc | ||||
| if len(bmarks) == 0 and fm.isplain(): | if len(bmarks) == 0 and fm.isplain(): | ||||
| ui.status(_(b"no bookmarks set\n")) | ui.status(_(b"no bookmarks set\n")) | ||||
| for bmark, (n, prefix, label) in sorted(pycompat.iteritems(bmarks)): | for bmark, (n, prefix, label) in sorted(bmarks.items()): | ||||
| fm.startitem() | fm.startitem() | ||||
| fm.context(repo=repo) | fm.context(repo=repo) | ||||
| if not ui.quiet: | if not ui.quiet: | ||||
| fm.plain(b' %s ' % prefix, label=label) | fm.plain(b' %s ' % prefix, label=label) | ||||
| fm.write(b'bookmark', b'%s', bmark, label=label) | fm.write(b'bookmark', b'%s', bmark, label=label) | ||||
| pad = b" " * (25 - encoding.colwidth(bmark)) | pad = b" " * (25 - encoding.colwidth(bmark)) | ||||
| fm.condwrite( | fm.condwrite( | ||||
| not ui.quiet, | not ui.quiet, | ||||
| self._verifybranch(key) | self._verifybranch(key) | ||||
| return self._entries[key] | return self._entries[key] | ||||
| def __contains__(self, key): | def __contains__(self, key): | ||||
| self._verifybranch(key) | self._verifybranch(key) | ||||
| return key in self._entries | return key in self._entries | ||||
| def iteritems(self): | def iteritems(self): | ||||
| for k, v in pycompat.iteritems(self._entries): | for k, v in self._entries.items(): | ||||
| self._verifybranch(k) | self._verifybranch(k) | ||||
| yield k, v | yield k, v | ||||
| items = iteritems | items = iteritems | ||||
| def hasbranch(self, label): | def hasbranch(self, label): | ||||
| """checks whether a branch of this name exists or not""" | """checks whether a branch of this name exists or not""" | ||||
| self._verifybranch(label) | self._verifybranch(label) | ||||
| def branchheads(self, branch, closed=False): | def branchheads(self, branch, closed=False): | ||||
| self._verifybranch(branch) | self._verifybranch(branch) | ||||
| heads = self._entries[branch] | heads = self._entries[branch] | ||||
| if not closed: | if not closed: | ||||
| heads = list(self.iteropen(heads)) | heads = list(self.iteropen(heads)) | ||||
| return heads | return heads | ||||
| def iterbranches(self): | def iterbranches(self): | ||||
| for bn, heads in pycompat.iteritems(self): | for bn, heads in self.items(): | ||||
| yield (bn, heads) + self._branchtip(heads) | yield (bn, heads) + self._branchtip(heads) | ||||
| def iterheads(self): | def iterheads(self): | ||||
| """returns all the heads""" | """returns all the heads""" | ||||
| self._verifyall() | self._verifyall() | ||||
| return pycompat.itervalues(self._entries) | return pycompat.itervalues(self._entries) | ||||
| def copy(self): | def copy(self): | ||||
| return | return | ||||
| try: | try: | ||||
| f = repo.cachevfs(self._filename(repo), b"w", atomictemp=True) | f = repo.cachevfs(self._filename(repo), b"w", atomictemp=True) | ||||
| cachekey = [hex(self.tipnode), b'%d' % self.tiprev] | cachekey = [hex(self.tipnode), b'%d' % self.tiprev] | ||||
| if self.filteredhash is not None: | if self.filteredhash is not None: | ||||
| cachekey.append(hex(self.filteredhash)) | cachekey.append(hex(self.filteredhash)) | ||||
| f.write(b" ".join(cachekey) + b'\n') | f.write(b" ".join(cachekey) + b'\n') | ||||
| nodecount = 0 | nodecount = 0 | ||||
| for label, nodes in sorted(pycompat.iteritems(self._entries)): | for label, nodes in sorted(self._entries.items()): | ||||
| label = encoding.fromlocal(label) | label = encoding.fromlocal(label) | ||||
| for node in nodes: | for node in nodes: | ||||
| nodecount += 1 | nodecount += 1 | ||||
| if node in self._closednodes: | if node in self._closednodes: | ||||
| state = b'c' | state = b'c' | ||||
| else: | else: | ||||
| state = b'o' | state = b'o' | ||||
| f.write(b"%s %s %s\n" % (hex(node), state, label)) | f.write(b"%s %s %s\n" % (hex(node), state, label)) | ||||
| # If a changeset is visible, its parents must be visible too, so | # If a changeset is visible, its parents must be visible too, so | ||||
| # use the faster unfiltered parent accessor. | # use the faster unfiltered parent accessor. | ||||
| parentrevs = repo.unfiltered().changelog.parentrevs | parentrevs = repo.unfiltered().changelog.parentrevs | ||||
| # Faster than using ctx.obsolete() | # Faster than using ctx.obsolete() | ||||
| obsrevs = obsolete.getrevs(repo, b'obsolete') | obsrevs = obsolete.getrevs(repo, b'obsolete') | ||||
| for branch, newheadrevs in pycompat.iteritems(newbranches): | for branch, newheadrevs in newbranches.items(): | ||||
| # For every branch, compute the new branchheads. | # For every branch, compute the new branchheads. | ||||
| # A branchhead is a revision such that no descendant is on | # A branchhead is a revision such that no descendant is on | ||||
| # the same branch. | # the same branch. | ||||
| # | # | ||||
| # The branchheads are computed iteratively in revision order. | # The branchheads are computed iteratively in revision order. | ||||
| # This ensures topological order, i.e. parents are processed | # This ensures topological order, i.e. parents are processed | ||||
| # before their children. Ancestors are inclusive here, i.e. | # before their children. Ancestors are inclusive here, i.e. | ||||
| # any revision is an ancestor of itself. | # any revision is an ancestor of itself. | ||||
| phasetonodes = phases.binarydecode(inpart) | phasetonodes = phases.binarydecode(inpart) | ||||
| unfi = op.repo.unfiltered() | unfi = op.repo.unfiltered() | ||||
| cl = unfi.changelog | cl = unfi.changelog | ||||
| phasecache = unfi._phasecache | phasecache = unfi._phasecache | ||||
| msg = ( | msg = ( | ||||
| b'remote repository changed while pushing - please try again ' | b'remote repository changed while pushing - please try again ' | ||||
| b'(%s is %s expected %s)' | b'(%s is %s expected %s)' | ||||
| ) | ) | ||||
| for expectedphase, nodes in pycompat.iteritems(phasetonodes): | for expectedphase, nodes in phasetonodes.items(): | ||||
| for n in nodes: | for n in nodes: | ||||
| actualphase = phasecache.phase(unfi, cl.rev(n)) | actualphase = phasecache.phase(unfi, cl.rev(n)) | ||||
| if actualphase != expectedphase: | if actualphase != expectedphase: | ||||
| finalmsg = msg % ( | finalmsg = msg % ( | ||||
| short(n), | short(n), | ||||
| phases.phasenames[actualphase], | phases.phasenames[actualphase], | ||||
| phases.phasenames[expectedphase], | phases.phasenames[expectedphase], | ||||
| ) | ) | ||||
| if repo.ui.configbool(b'server', b'validate'): | if repo.ui.configbool(b'server', b'validate'): | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| ml = repo.manifestlog | ml = repo.manifestlog | ||||
| # validate incoming csets have their manifests | # validate incoming csets have their manifests | ||||
| for cset in pycompat.xrange(clstart, clend): | for cset in pycompat.xrange(clstart, clend): | ||||
| mfnode = cl.changelogrevision(cset).manifest | mfnode = cl.changelogrevision(cset).manifest | ||||
| mfest = ml[mfnode].readdelta() | mfest = ml[mfnode].readdelta() | ||||
| # store file nodes we must see | # store file nodes we must see | ||||
| for f, n in pycompat.iteritems(mfest): | for f, n in mfest.items(): | ||||
| needfiles.setdefault(f, set()).add(n) | needfiles.setdefault(f, set()).add(n) | ||||
| on_filelog_rev = None | on_filelog_rev = None | ||||
| if sidedata_helpers: | if sidedata_helpers: | ||||
| if revlog_constants.KIND_FILELOG in sidedata_helpers[1]: | if revlog_constants.KIND_FILELOG in sidedata_helpers[1]: | ||||
| def on_filelog_rev(filelog, rev): | def on_filelog_rev(filelog, rev): | ||||
| range = touched_filelogs.get(filelog) | range = touched_filelogs.get(filelog) | ||||
| self._verbosenote(_(b'%8.i (manifests)\n') % size) | self._verbosenote(_(b'%8.i (manifests)\n') % size) | ||||
| yield self._manifestsend | yield self._manifestsend | ||||
| mfdicts = None | mfdicts = None | ||||
| if self._ellipses and self._isshallow: | if self._ellipses and self._isshallow: | ||||
| mfdicts = [ | mfdicts = [ | ||||
| (repo.manifestlog[n].read(), lr) | (repo.manifestlog[n].read(), lr) | ||||
| for (n, lr) in pycompat.iteritems(manifests) | for (n, lr) in manifests.items() | ||||
| ] | ] | ||||
| manifests.clear() | manifests.clear() | ||||
| clrevs = {cl.rev(x) for x in clnodes} | clrevs = {cl.rev(x) for x in clnodes} | ||||
| it = self.generatefiles( | it = self.generatefiles( | ||||
| changedfiles, | changedfiles, | ||||
| commonrevs, | commonrevs, | ||||
| if n in needs: | if n in needs: | ||||
| needs.remove(n) | needs.remove(n) | ||||
| else: | else: | ||||
| raise error.Abort(_(b"received spurious file revlog entry")) | raise error.Abort(_(b"received spurious file revlog entry")) | ||||
| if not needs: | if not needs: | ||||
| del needfiles[f] | del needfiles[f] | ||||
| progress.complete() | progress.complete() | ||||
| for f, needs in pycompat.iteritems(needfiles): | for f, needs in needfiles.items(): | ||||
| fl = repo.file(f) | fl = repo.file(f) | ||||
| for n in needs: | for n in needs: | ||||
| try: | try: | ||||
| fl.rev(n) | fl.rev(n) | ||||
| except error.LookupError: | except error.LookupError: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _(b'missing file data for %s:%s - run hg verify') | _(b'missing file data for %s:%s - run hg verify') | ||||
| % (f, hex(n)) | % (f, hex(n)) | ||||
| ) | ) | ||||
| return revisions, files | return revisions, files | ||||
| sectionhash = _hashlist(sectionitems) | sectionhash = _hashlist(sectionitems) | ||||
| # If $CHGHG is set, the change to $HG should not trigger a new chg server | # If $CHGHG is set, the change to $HG should not trigger a new chg server | ||||
| if b'CHGHG' in encoding.environ: | if b'CHGHG' in encoding.environ: | ||||
| ignored = {b'HG'} | ignored = {b'HG'} | ||||
| else: | else: | ||||
| ignored = set() | ignored = set() | ||||
| envitems = [ | envitems = [ | ||||
| (k, v) | (k, v) | ||||
| for k, v in pycompat.iteritems(encoding.environ) | for k, v in encoding.environ.items() | ||||
| if _envre.match(k) and k not in ignored | if _envre.match(k) and k not in ignored | ||||
| ] | ] | ||||
| envhash = _hashlist(sorted(envitems)) | envhash = _hashlist(sorted(envitems)) | ||||
| return sectionhash[:6] + envhash[:6] | return sectionhash[:6] + envhash[:6] | ||||
| def _getmtimepaths(ui): | def _getmtimepaths(ui): | ||||
| """get a list of paths that should be checked to detect change | """get a list of paths that should be checked to detect change | ||||
| def __init__(self, in_, out, channel): | def __init__(self, in_, out, channel): | ||||
| self.in_ = in_ | self.in_ = in_ | ||||
| self.out = out | self.out = out | ||||
| self.channel = channel | self.channel = channel | ||||
| def __call__(self, cmd, environ, cwd=None, type=b'system', cmdtable=None): | def __call__(self, cmd, environ, cwd=None, type=b'system', cmdtable=None): | ||||
| args = [type, cmd, util.abspath(cwd or b'.')] | args = [type, cmd, util.abspath(cwd or b'.')] | ||||
| args.extend(b'%s=%s' % (k, v) for k, v in pycompat.iteritems(environ)) | args.extend(b'%s=%s' % (k, v) for k, v in environ.items()) | ||||
| data = b'\0'.join(args) | data = b'\0'.join(args) | ||||
| self.out.write(struct.pack(b'>cI', self.channel, len(data))) | self.out.write(struct.pack(b'>cI', self.channel, len(data))) | ||||
| self.out.write(data) | self.out.write(data) | ||||
| self.out.flush() | self.out.flush() | ||||
| if type == b'system': | if type == b'system': | ||||
| length = self.in_.read(4) | length = self.in_.read(4) | ||||
| (length,) = struct.unpack(b'>I', length) | (length,) = struct.unpack(b'>I', length) | ||||
| # Make all of the pathnames absolute. | # Make all of the pathnames absolute. | ||||
| newfiles = [repo.wjoin(nf) for nf in newfiles] | newfiles = [repo.wjoin(nf) for nf in newfiles] | ||||
| return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts)) | return commitfunc(ui, repo, *newfiles, **pycompat.strkwargs(opts)) | ||||
| finally: | finally: | ||||
| # 5. finally restore backed-up files | # 5. finally restore backed-up files | ||||
| try: | try: | ||||
| dirstate = repo.dirstate | dirstate = repo.dirstate | ||||
| for realname, tmpname in pycompat.iteritems(backups): | for realname, tmpname in backups.items(): | ||||
| ui.debug(b'restoring %r to %r\n' % (tmpname, realname)) | ui.debug(b'restoring %r to %r\n' % (tmpname, realname)) | ||||
| if dirstate.get_entry(realname).maybe_clean: | if dirstate.get_entry(realname).maybe_clean: | ||||
| # without normallookup, restoring timestamp | # without normallookup, restoring timestamp | ||||
| # may cause partially committed files | # may cause partially committed files | ||||
| # to be treated as unmodified | # to be treated as unmodified | ||||
| # XXX-PENDINGCHANGE: We should clarify the context in | # XXX-PENDINGCHANGE: We should clarify the context in | ||||
| b'debugcommands', | b'debugcommands', | ||||
| [], | [], | ||||
| _(b'[COMMAND]'), | _(b'[COMMAND]'), | ||||
| helpcategory=command.CATEGORY_HELP, | helpcategory=command.CATEGORY_HELP, | ||||
| norepo=True, | norepo=True, | ||||
| ) | ) | ||||
| def debugcommands(ui, cmd=b'', *args): | def debugcommands(ui, cmd=b'', *args): | ||||
| """list all available commands and options""" | """list all available commands and options""" | ||||
| for cmd, vals in sorted(pycompat.iteritems(table)): | for cmd, vals in sorted(table.items()): | ||||
| cmd = cmd.split(b'|')[0] | cmd = cmd.split(b'|')[0] | ||||
| opts = b', '.join([i[1] for i in vals[1]]) | opts = b', '.join([i[1] for i in vals[1]]) | ||||
| ui.write(b'%s: %s\n' % (cmd, opts)) | ui.write(b'%s: %s\n' % (cmd, opts)) | ||||
| @command( | @command( | ||||
| b'debugcomplete', | b'debugcomplete', | ||||
| [(b'o', b'options', None, _(b'show the command options'))], | [(b'o', b'options', None, _(b'show the command options'))], | ||||
| for m in marks: | for m in marks: | ||||
| ui.write(b' ' + m, label=b'log.bookmark') | ui.write(b' ' + m, label=b'log.bookmark') | ||||
| ui.write(b'\n', label=b'log.bookmark') | ui.write(b'\n', label=b'log.bookmark') | ||||
| status = repo.status(unknown=True) | status = repo.status(unknown=True) | ||||
| c = repo.dirstate.copies() | c = repo.dirstate.copies() | ||||
| copied, renamed = [], [] | copied, renamed = [], [] | ||||
| for d, s in pycompat.iteritems(c): | for d, s in c.items(): | ||||
| if s in status.removed: | if s in status.removed: | ||||
| status.removed.remove(s) | status.removed.remove(s) | ||||
| renamed.append(d) | renamed.append(d) | ||||
| else: | else: | ||||
| copied.append(d) | copied.append(d) | ||||
| if d in status.added: | if d in status.added: | ||||
| status.added.remove(d) | status.added.remove(d) | ||||
| mf2 = self._buildstatusmanifest(s) | mf2 = self._buildstatusmanifest(s) | ||||
| modified, added = [], [] | modified, added = [], [] | ||||
| removed = [] | removed = [] | ||||
| clean = [] | clean = [] | ||||
| deleted, unknown, ignored = s.deleted, s.unknown, s.ignored | deleted, unknown, ignored = s.deleted, s.unknown, s.ignored | ||||
| deletedset = set(deleted) | deletedset = set(deleted) | ||||
| d = mf1.diff(mf2, match=match, clean=listclean) | d = mf1.diff(mf2, match=match, clean=listclean) | ||||
| for fn, value in pycompat.iteritems(d): | for fn, value in d.items(): | ||||
| if fn in deletedset: | if fn in deletedset: | ||||
| continue | continue | ||||
| if value is None: | if value is None: | ||||
| clean.append(fn) | clean.append(fn) | ||||
| continue | continue | ||||
| (node1, flag1), (node2, flag2) = value | (node1, flag1), (node2, flag2) = value | ||||
| if node1 is None: | if node1 is None: | ||||
| added.append(fn) | added.append(fn) | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import nullrev | from .node import nullrev | ||||
| from . import ( | from . import ( | ||||
| match as matchmod, | match as matchmod, | ||||
| pathutil, | pathutil, | ||||
| policy, | policy, | ||||
| pycompat, | |||||
| util, | util, | ||||
| ) | ) | ||||
| from .utils import stringutil | from .utils import stringutil | ||||
| from .revlogutils import ( | from .revlogutils import ( | ||||
| flagutil, | flagutil, | ||||
| elif k not in dst: # case 1 | elif k not in dst: # case 1 | ||||
| # remove copies to files that were then removed | # remove copies to files that were then removed | ||||
| del t[k] | del t[k] | ||||
| def _chain(prefix, suffix): | def _chain(prefix, suffix): | ||||
| """chain two sets of copies 'prefix' and 'suffix'""" | """chain two sets of copies 'prefix' and 'suffix'""" | ||||
| result = prefix.copy() | result = prefix.copy() | ||||
| for key, value in pycompat.iteritems(suffix): | for key, value in suffix.items(): | ||||
| result[key] = prefix.get(value, value) | result[key] = prefix.get(value, value) | ||||
| return result | return result | ||||
| def _tracefile(fctx, am, basemf): | def _tracefile(fctx, am, basemf): | ||||
| """return file context that is the ancestor of fctx present in ancestor | """return file context that is the ancestor of fctx present in ancestor | ||||
| manifest am | manifest am | ||||
| childcopies = {} | childcopies = {} | ||||
| if parent == 1: | if parent == 1: | ||||
| childcopies = changes.copied_from_p1 | childcopies = changes.copied_from_p1 | ||||
| elif parent == 2: | elif parent == 2: | ||||
| childcopies = changes.copied_from_p2 | childcopies = changes.copied_from_p2 | ||||
| if childcopies: | if childcopies: | ||||
| newcopies = copies.copy() | newcopies = copies.copy() | ||||
| for dest, source in pycompat.iteritems(childcopies): | for dest, source in childcopies.items(): | ||||
| prev = copies.get(source) | prev = copies.get(source) | ||||
| if prev is not None and prev[1] is not None: | if prev is not None and prev[1] is not None: | ||||
| source = prev[1] | source = prev[1] | ||||
| newcopies[dest] = (current_rev, source) | newcopies[dest] = (current_rev, source) | ||||
| assert newcopies is not copies | assert newcopies is not copies | ||||
| if changes.removed: | if changes.removed: | ||||
| for f in changes.removed: | for f in changes.removed: | ||||
| if f in newcopies: | if f in newcopies: | ||||
| childcopies = p2copies | childcopies = p2copies | ||||
| if not alwaysmatch: | if not alwaysmatch: | ||||
| childcopies = { | childcopies = { | ||||
| dst: src for dst, src in childcopies.items() if match(dst) | dst: src for dst, src in childcopies.items() if match(dst) | ||||
| } | } | ||||
| newcopies = copies | newcopies = copies | ||||
| if childcopies: | if childcopies: | ||||
| newcopies = copies.copy() | newcopies = copies.copy() | ||||
| for dest, source in pycompat.iteritems(childcopies): | for dest, source in childcopies.items(): | ||||
| prev = copies.get(source) | prev = copies.get(source) | ||||
| if prev is not None and prev[1] is not None: | if prev is not None and prev[1] is not None: | ||||
| source = prev[1] | source = prev[1] | ||||
| newcopies[dest] = (c, source) | newcopies[dest] = (c, source) | ||||
| assert newcopies is not copies | assert newcopies is not copies | ||||
| for f in removed: | for f in removed: | ||||
| if f in newcopies: | if f in newcopies: | ||||
| if newcopies is copies: | if newcopies is copies: | ||||
| def _reverse_renames(copies, dst, match): | def _reverse_renames(copies, dst, match): | ||||
| """given copies to context 'dst', finds renames from that context""" | """given copies to context 'dst', finds renames from that context""" | ||||
| # Even though we're not taking copies into account, 1:n rename situations | # Even though we're not taking copies into account, 1:n rename situations | ||||
| # can still exist (e.g. hg cp a b; hg mv a c). In those cases we | # can still exist (e.g. hg cp a b; hg mv a c). In those cases we | ||||
| # arbitrarily pick one of the renames. | # arbitrarily pick one of the renames. | ||||
| r = {} | r = {} | ||||
| for k, v in sorted(pycompat.iteritems(copies)): | for k, v in sorted(copies.items()): | ||||
| if match and not match(v): | if match and not match(v): | ||||
| continue | continue | ||||
| # remove copies | # remove copies | ||||
| if v in dst: | if v in dst: | ||||
| continue | continue | ||||
| r[v] = k | r[v] = k | ||||
| return r | return r | ||||
| ctx) | ctx) | ||||
| """ | """ | ||||
| # generate a directory move map | # generate a directory move map | ||||
| invalid = set() | invalid = set() | ||||
| dirmove = {} | dirmove = {} | ||||
| # examine each file copy for a potential directory move, which is | # examine each file copy for a potential directory move, which is | ||||
| # when all the files in a directory are moved to a new directory | # when all the files in a directory are moved to a new directory | ||||
| for dst, src in pycompat.iteritems(fullcopy): | for dst, src in fullcopy.items(): | ||||
| dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst) | dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst) | ||||
| if dsrc in invalid: | if dsrc in invalid: | ||||
| # already seen to be uninteresting | # already seen to be uninteresting | ||||
| continue | continue | ||||
| elif ctx.hasdir(dsrc) and ctx.hasdir(ddst): | elif ctx.hasdir(dsrc) and ctx.hasdir(ddst): | ||||
| # directory wasn't entirely moved locally | # directory wasn't entirely moved locally | ||||
| invalid.add(dsrc) | invalid.add(dsrc) | ||||
| elif dsrc in dirmove and dirmove[dsrc] != ddst: | elif dsrc in dirmove and dirmove[dsrc] != ddst: | ||||
| # files from the same directory moved to two different places | # files from the same directory moved to two different places | ||||
| invalid.add(dsrc) | invalid.add(dsrc) | ||||
| else: | else: | ||||
| # looks good so far | # looks good so far | ||||
| dirmove[dsrc] = ddst | dirmove[dsrc] = ddst | ||||
| for i in invalid: | for i in invalid: | ||||
| if i in dirmove: | if i in dirmove: | ||||
| del dirmove[i] | del dirmove[i] | ||||
| del invalid | del invalid | ||||
| if not dirmove: | if not dirmove: | ||||
| return {}, {} | return {}, {} | ||||
| dirmove = {k + b"/": v + b"/" for k, v in pycompat.iteritems(dirmove)} | dirmove = {k + b"/": v + b"/" for k, v in dirmove.items()} | ||||
| for d in dirmove: | for d in dirmove: | ||||
| repo.ui.debug( | repo.ui.debug( | ||||
| b" discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d]) | b" discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d]) | ||||
| ) | ) | ||||
| # Sort the directories in reverse order, so we find children first | # Sort the directories in reverse order, so we find children first | ||||
| # For example, if dir1/ was renamed to dir2/, and dir1/subdir1/ | # For example, if dir1/ was renamed to dir2/, and dir1/subdir1/ | ||||
| # To keep things simple let's not handle merges | # To keep things simple let's not handle merges | ||||
| repo.ui.debug(b"switching to full copytracing because of merges\n") | repo.ui.debug(b"switching to full copytracing because of merges\n") | ||||
| return _fullcopytracing(repo, c1, c2, base) | return _fullcopytracing(repo, c1, c2, base) | ||||
| changedfiles.update(ctx.files()) | changedfiles.update(ctx.files()) | ||||
| ctx = ctx.p1() | ctx = ctx.p1() | ||||
| copies2 = {} | copies2 = {} | ||||
| cp = _forwardcopies(base, c2) | cp = _forwardcopies(base, c2) | ||||
| for dst, src in pycompat.iteritems(cp): | for dst, src in cp.items(): | ||||
| if src in m1: | if src in m1: | ||||
| copies2[dst] = src | copies2[dst] = src | ||||
| # file is missing if it isn't present in the destination, but is present in | # file is missing if it isn't present in the destination, but is present in | ||||
| # the base and present in the source. | # the base and present in the source. | ||||
| # Presence in the base is important to exclude added files, presence in the | # Presence in the base is important to exclude added files, presence in the | ||||
| # source is important to exclude removed files. | # source is important to exclude removed files. | ||||
| filt = lambda f: f not in m1 and f in base and f in c2 | filt = lambda f: f not in m1 and f in base and f in c2 | ||||
| # Extra filtering to drop copy information for files that existed before | # Extra filtering to drop copy information for files that existed before | ||||
| # the graft. This is to handle the case of grafting a rename onto a commit | # the graft. This is to handle the case of grafting a rename onto a commit | ||||
| # that already has the rename. Otherwise the presence of copy information | # that already has the rename. Otherwise the presence of copy information | ||||
| # would result in the creation of an empty commit where we would prefer to | # would result in the creation of an empty commit where we would prefer to | ||||
| # not create one. | # not create one. | ||||
| for dest, __ in list(new_copies.items()): | for dest, __ in list(new_copies.items()): | ||||
| if dest in parent: | if dest in parent: | ||||
| del new_copies[dest] | del new_copies[dest] | ||||
| for dst, src in pycompat.iteritems(new_copies): | for dst, src in new_copies.items(): | ||||
| wctx[dst].markcopied(src) | wctx[dst].markcopied(src) | ||||
| try: | try: | ||||
| caps = peer.capabilities() | caps = peer.capabilities() | ||||
| ui.writenoi18n(b'Main capabilities:\n') | ui.writenoi18n(b'Main capabilities:\n') | ||||
| for c in sorted(caps): | for c in sorted(caps): | ||||
| ui.write(b' %s\n' % c) | ui.write(b' %s\n' % c) | ||||
| b2caps = bundle2.bundle2caps(peer) | b2caps = bundle2.bundle2caps(peer) | ||||
| if b2caps: | if b2caps: | ||||
| ui.writenoi18n(b'Bundle2 capabilities:\n') | ui.writenoi18n(b'Bundle2 capabilities:\n') | ||||
| for key, values in sorted(pycompat.iteritems(b2caps)): | for key, values in sorted(b2caps.items()): | ||||
| ui.write(b' %s\n' % key) | ui.write(b' %s\n' % key) | ||||
| for v in values: | for v in values: | ||||
| ui.write(b' %s\n' % v) | ui.write(b' %s\n' % v) | ||||
| finally: | finally: | ||||
| peer.close() | peer.close() | ||||
| @command( | @command( | ||||
| fm_files.end() | fm_files.end() | ||||
| fm_extras = fm.nested(b'extras') | fm_extras = fm.nested(b'extras') | ||||
| for f, d in sorted(pycompat.iteritems(ms.allextras())): | for f, d in sorted(pycompat.iteritems(ms.allextras())): | ||||
| if f in ms: | if f in ms: | ||||
| # If file is in mergestate, we have already processed it's extras | # If file is in mergestate, we have already processed it's extras | ||||
| continue | continue | ||||
| for k, v in pycompat.iteritems(d): | for k, v in d.items(): | ||||
| fm_extras.startitem() | fm_extras.startitem() | ||||
| fm_extras.data(file=f) | fm_extras.data(file=f) | ||||
| fm_extras.data(key=k) | fm_extras.data(key=k) | ||||
| fm_extras.data(value=v) | fm_extras.data(value=v) | ||||
| fm_extras.end() | fm_extras.end() | ||||
| fm.end() | fm.end() | ||||
| @command(b'debugnamecomplete', [], _(b'NAME...')) | @command(b'debugnamecomplete', [], _(b'NAME...')) | ||||
| def debugnamecomplete(ui, repo, *args): | def debugnamecomplete(ui, repo, *args): | ||||
| '''complete "names" - tags, open branch names, bookmark names''' | '''complete "names" - tags, open branch names, bookmark names''' | ||||
| names = set() | names = set() | ||||
| # since we previously only listed open branches, we will handle that | # since we previously only listed open branches, we will handle that | ||||
| # specially (after this for loop) | # specially (after this for loop) | ||||
| for name, ns in pycompat.iteritems(repo.names): | for name, ns in repo.names.items(): | ||||
| if name != b'branches': | if name != b'branches': | ||||
| names.update(ns.listnames(repo)) | names.update(ns.listnames(repo)) | ||||
| names.update( | names.update( | ||||
| tag | tag | ||||
| for (tag, heads, tip, closed) in repo.branchmap().iterbranches() | for (tag, heads, tip, closed) in repo.branchmap().iterbranches() | ||||
| if not closed | if not closed | ||||
| ) | ) | ||||
| completions = set() | completions = set() | ||||
| spec = spec[len(rootdir) :] | spec = spec[len(rootdir) :] | ||||
| fixpaths = pycompat.ossep != b'/' | fixpaths = pycompat.ossep != b'/' | ||||
| if fixpaths: | if fixpaths: | ||||
| spec = spec.replace(pycompat.ossep, b'/') | spec = spec.replace(pycompat.ossep, b'/') | ||||
| speclen = len(spec) | speclen = len(spec) | ||||
| fullpaths = opts['full'] | fullpaths = opts['full'] | ||||
| files, dirs = set(), set() | files, dirs = set(), set() | ||||
| adddir, addfile = dirs.add, files.add | adddir, addfile = dirs.add, files.add | ||||
| for f, st in pycompat.iteritems(dirstate): | for f, st in dirstate.items(): | ||||
| if f.startswith(spec) and st.state in acceptable: | if f.startswith(spec) and st.state in acceptable: | ||||
| if fixpaths: | if fixpaths: | ||||
| f = f.replace(b'/', pycompat.ossep) | f = f.replace(b'/', pycompat.ossep) | ||||
| if fullpaths: | if fullpaths: | ||||
| addfile(f) | addfile(f) | ||||
| continue | continue | ||||
| s = f.find(pycompat.ossep, speclen) | s = f.find(pycompat.ossep, speclen) | ||||
| if s >= 0: | if s >= 0: | ||||
| ) | ) | ||||
| def debugwireargs(ui, repopath, *vals, **opts): | def debugwireargs(ui, repopath, *vals, **opts): | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| repo = hg.peer(ui, opts, repopath) | repo = hg.peer(ui, opts, repopath) | ||||
| try: | try: | ||||
| for opt in cmdutil.remoteopts: | for opt in cmdutil.remoteopts: | ||||
| del opts[opt[1]] | del opts[opt[1]] | ||||
| args = {} | args = {} | ||||
| for k, v in pycompat.iteritems(opts): | for k, v in opts.items(): | ||||
| if v: | if v: | ||||
| args[k] = v | args[k] = v | ||||
| args = pycompat.strkwargs(args) | args = pycompat.strkwargs(args) | ||||
| # run twice to check that we don't mess up the stream for the next command | # run twice to check that we don't mess up the stream for the next command | ||||
| res1 = repo.debugwireargs(*vals, **args) | res1 = repo.debugwireargs(*vals, **args) | ||||
| res2 = repo.debugwireargs(*vals, **args) | res2 = repo.debugwireargs(*vals, **args) | ||||
| ui.write(b"%s\n" % res1) | ui.write(b"%s\n" % res1) | ||||
| if res1 != res2: | if res1 != res2: | ||||
| def __contains__(self, key): | def __contains__(self, key): | ||||
| return key in self._map | return key in self._map | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return iter(sorted(self._map)) | return iter(sorted(self._map)) | ||||
| def items(self): | def items(self): | ||||
| return pycompat.iteritems(self._map) | return self._map.items() | ||||
| iteritems = items | iteritems = items | ||||
| def parents(self): | def parents(self): | ||||
| return [self._validate(p) for p in self._pl] | return [self._validate(p) for p in self._pl] | ||||
| def p1(self): | def p1(self): | ||||
| return self._validate(self._pl[0]) | return self._validate(self._pl[0]) | ||||
| Category is a unique identifier to allow overwriting an old callback | Category is a unique identifier to allow overwriting an old callback | ||||
| with a newer callback. | with a newer callback. | ||||
| """ | """ | ||||
| self._plchangecallbacks[category] = callback | self._plchangecallbacks[category] = callback | ||||
| def _writedirstate(self, tr, st): | def _writedirstate(self, tr, st): | ||||
| # notify callbacks about parents change | # notify callbacks about parents change | ||||
| if self._origpl is not None and self._origpl != self._pl: | if self._origpl is not None and self._origpl != self._pl: | ||||
| for c, callback in sorted( | for c, callback in sorted(self._plchangecallbacks.items()): | ||||
| pycompat.iteritems(self._plchangecallbacks) | |||||
| ): | |||||
| callback(self, self._origpl, self._pl) | callback(self, self._origpl, self._pl) | ||||
| self._origpl = None | self._origpl = None | ||||
| self._map.write(tr, st) | self._map.write(tr, st) | ||||
| self._dirty = False | self._dirty = False | ||||
| self._dirty_tracked_set = False | self._dirty_tracked_set = False | ||||
| def _write_tracked_hint(self, tr, f): | def _write_tracked_hint(self, tr, f): | ||||
| key = node.hex(uuid.uuid4().bytes) | key = node.hex(uuid.uuid4().bytes) | ||||
| # Case insensitive filesystems cannot rely on lstat() failing to detect | # Case insensitive filesystems cannot rely on lstat() failing to detect | ||||
| # a case-only rename. Prune the stat object for any file that does not | # a case-only rename. Prune the stat object for any file that does not | ||||
| # match the case in the filesystem, if there are multiple files that | # match the case in the filesystem, if there are multiple files that | ||||
| # normalize to the same path. | # normalize to the same path. | ||||
| if match.isexact() and self._checkcase: | if match.isexact() and self._checkcase: | ||||
| normed = {} | normed = {} | ||||
| for f, st in pycompat.iteritems(results): | for f, st in results.items(): | ||||
| if st is None: | if st is None: | ||||
| continue | continue | ||||
| nc = util.normcase(f) | nc = util.normcase(f) | ||||
| paths = normed.get(nc) | paths = normed.get(nc) | ||||
| if paths is None: | if paths is None: | ||||
| paths = set() | paths = set() | ||||
| normed[nc] = paths | normed[nc] = paths | ||||
| paths.add(f) | paths.add(f) | ||||
| for norm, paths in pycompat.iteritems(normed): | for norm, paths in normed.items(): | ||||
| if len(paths) > 1: | if len(paths) > 1: | ||||
| for path in paths: | for path in paths: | ||||
| folded = self._discoverpath( | folded = self._discoverpath( | ||||
| path, norm, True, None, self._map.dirfoldmap | path, norm, True, None, self._map.dirfoldmap | ||||
| ) | ) | ||||
| if path != folded: | if path != folded: | ||||
| results[path] = None | results[path] = None | ||||
| # dirstatemap.py | # dirstatemap.py | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| import errno | import errno | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| pathutil, | pathutil, | ||||
| policy, | policy, | ||||
| pycompat, | |||||
| txnutil, | txnutil, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from .dirstateutils import ( | from .dirstateutils import ( | ||||
| docket as docketmod, | docket as docketmod, | ||||
| v2, | v2, | ||||
| ) | ) | ||||
| self.copymap.clear() | self.copymap.clear() | ||||
| self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid) | self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid) | ||||
| util.clearcachedproperty(self, b"_dirs") | util.clearcachedproperty(self, b"_dirs") | ||||
| util.clearcachedproperty(self, b"_alldirs") | util.clearcachedproperty(self, b"_alldirs") | ||||
| util.clearcachedproperty(self, b"filefoldmap") | util.clearcachedproperty(self, b"filefoldmap") | ||||
| util.clearcachedproperty(self, b"dirfoldmap") | util.clearcachedproperty(self, b"dirfoldmap") | ||||
| def items(self): | def items(self): | ||||
| return pycompat.iteritems(self._map) | return self._map.items() | ||||
| # forward for python2,3 compat | # forward for python2,3 compat | ||||
| iteritems = items | iteritems = items | ||||
| def debug_iter(self, all): | def debug_iter(self, all): | ||||
| """ | """ | ||||
| Return an iterator of (filename, state, mode, size, mtime) tuples | Return an iterator of (filename, state, mode, size, mtime) tuples | ||||
| `all` is unused when Rust is not enabled | `all` is unused when Rust is not enabled | ||||
| """ | """ | ||||
| for (filename, item) in self.items(): | for (filename, item) in self.items(): | ||||
| yield (filename, item.state, item.mode, item.size, item.mtime) | yield (filename, item.state, item.mode, item.size, item.mtime) | ||||
| def keys(self): | def keys(self): | ||||
| return self._map.keys() | return self._map.keys() | ||||
| ### reading/setting parents | ### reading/setting parents | ||||
| def setparents(self, p1, p2, fold_p2=False): | def setparents(self, p1, p2, fold_p2=False): | ||||
| self._parents = (p1, p2) | self._parents = (p1, p2) | ||||
| self._dirtyparents = True | self._dirtyparents = True | ||||
| copies = {} | copies = {} | ||||
| if fold_p2: | if fold_p2: | ||||
| for f, s in pycompat.iteritems(self._map): | for f, s in self._map.items(): | ||||
| # Discard "merged" markers when moving away from a merge state | # Discard "merged" markers when moving away from a merge state | ||||
| if s.p2_info: | if s.p2_info: | ||||
| source = self.copymap.pop(f, None) | source = self.copymap.pop(f, None) | ||||
| if source: | if source: | ||||
| copies[f] = source | copies[f] = source | ||||
| s.drop_merge_data() | s.drop_merge_data() | ||||
| return copies | return copies | ||||
| pass | pass | ||||
| else: | else: | ||||
| return makefilefoldmap( | return makefilefoldmap( | ||||
| self._map, util.normcasespec, util.normcasefallback | self._map, util.normcasespec, util.normcasefallback | ||||
| ) | ) | ||||
| f = {} | f = {} | ||||
| normcase = util.normcase | normcase = util.normcase | ||||
| for name, s in pycompat.iteritems(self._map): | for name, s in self._map.items(): | ||||
| if not s.removed: | if not s.removed: | ||||
| f[normcase(name)] = name | f[normcase(name)] = name | ||||
| f[b'.'] = b'.' # prevents useless util.fspath() invocation | f[b'.'] = b'.' # prevents useless util.fspath() invocation | ||||
| return f | return f | ||||
| @propertycache | @propertycache | ||||
| def dirfoldmap(self): | def dirfoldmap(self): | ||||
| f = {} | f = {} | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| bookmarks, | bookmarks, | ||||
| branchmap, | branchmap, | ||||
| error, | error, | ||||
| obsolete, | obsolete, | ||||
| phases, | phases, | ||||
| pycompat, | |||||
| scmutil, | scmutil, | ||||
| setdiscovery, | setdiscovery, | ||||
| treediscovery, | treediscovery, | ||||
| util, | util, | ||||
| ) | ) | ||||
| def findcommonincoming(repo, remote, heads=None, force=False, ancestorsof=None): | def findcommonincoming(repo, remote, heads=None, force=False, ancestorsof=None): | ||||
| missingctx.add(ctx) | missingctx.add(ctx) | ||||
| branches.add(ctx.branch()) | branches.add(ctx.branch()) | ||||
| with remote.commandexecutor() as e: | with remote.commandexecutor() as e: | ||||
| remotemap = e.callcommand(b'branchmap', {}).result() | remotemap = e.callcommand(b'branchmap', {}).result() | ||||
| knownnode = cl.hasnode # do not use nodemap until it is filtered | knownnode = cl.hasnode # do not use nodemap until it is filtered | ||||
| # A. register remote heads of branches which are in outgoing set | # A. register remote heads of branches which are in outgoing set | ||||
| for branch, heads in pycompat.iteritems(remotemap): | for branch, heads in remotemap.items(): | ||||
| # don't add head info about branches which we don't have locally | # don't add head info about branches which we don't have locally | ||||
| if branch not in branches: | if branch not in branches: | ||||
| continue | continue | ||||
| known = [] | known = [] | ||||
| unsynced = [] | unsynced = [] | ||||
| for h in heads: | for h in heads: | ||||
| if knownnode(h): | if knownnode(h): | ||||
| known.append(h) | known.append(h) | ||||
| else: | else: | ||||
| unsynced.append(h) | unsynced.append(h) | ||||
| headssum[branch] = (known, list(known), unsynced) | headssum[branch] = (known, list(known), unsynced) | ||||
| # B. add new branch data | # B. add new branch data | ||||
| for branch in branches: | for branch in branches: | ||||
| if branch not in headssum: | if branch not in headssum: | ||||
| headssum[branch] = (None, [], []) | headssum[branch] = (None, [], []) | ||||
| # C. Update newmap with outgoing changes. | # C. Update newmap with outgoing changes. | ||||
| # This will possibly add new heads and remove existing ones. | # This will possibly add new heads and remove existing ones. | ||||
| newmap = branchmap.remotebranchcache( | newmap = branchmap.remotebranchcache( | ||||
| repo, | repo, | ||||
| ( | ( | ||||
| (branch, heads[1]) | (branch, heads[1]) | ||||
| for branch, heads in pycompat.iteritems(headssum) | for branch, heads in headssum.items() | ||||
| if heads[0] is not None | if heads[0] is not None | ||||
| ), | ), | ||||
| ) | ) | ||||
| newmap.update(repo, (ctx.rev() for ctx in missingctx)) | newmap.update(repo, (ctx.rev() for ctx in missingctx)) | ||||
| for branch, newheads in pycompat.iteritems(newmap): | for branch, newheads in newmap.items(): | ||||
| headssum[branch][1][:] = newheads | headssum[branch][1][:] = newheads | ||||
| for branch, items in pycompat.iteritems(headssum): | for branch, items in headssum.items(): | ||||
| for l in items: | for l in items: | ||||
| if l is not None: | if l is not None: | ||||
| l.sort() | l.sort() | ||||
| headssum[branch] = items + ([],) | headssum[branch] = items + ([],) | ||||
| # If there are no obsstore, no post processing are needed. | # If there are no obsstore, no post processing are needed. | ||||
| if repo.obsstore: | if repo.obsstore: | ||||
| torev = repo.changelog.rev | torev = repo.changelog.rev | ||||
| futureheads = {torev(h) for h in outgoing.ancestorsof} | futureheads = {torev(h) for h in outgoing.ancestorsof} | ||||
| futureheads |= {torev(h) for h in outgoing.commonheads} | futureheads |= {torev(h) for h in outgoing.commonheads} | ||||
| allfuturecommon = repo.changelog.ancestors(futureheads, inclusive=True) | allfuturecommon = repo.changelog.ancestors(futureheads, inclusive=True) | ||||
| for branch, heads in sorted(pycompat.iteritems(headssum)): | for branch, heads in sorted(headssum.items()): | ||||
| remoteheads, newheads, unsyncedheads, placeholder = heads | remoteheads, newheads, unsyncedheads, placeholder = heads | ||||
| result = _postprocessobsolete(pushop, allfuturecommon, newheads) | result = _postprocessobsolete(pushop, allfuturecommon, newheads) | ||||
| headssum[branch] = ( | headssum[branch] = ( | ||||
| remoteheads, | remoteheads, | ||||
| sorted(result[0]), | sorted(result[0]), | ||||
| unsyncedheads, | unsyncedheads, | ||||
| sorted(result[1]), | sorted(result[1]), | ||||
| ) | ) | ||||
| return | return | ||||
| if remote.capable(b'branchmap'): | if remote.capable(b'branchmap'): | ||||
| headssum = _headssummary(pushop) | headssum = _headssummary(pushop) | ||||
| else: | else: | ||||
| headssum = _oldheadssummary(repo, remoteheads, outgoing, inc) | headssum = _oldheadssummary(repo, remoteheads, outgoing, inc) | ||||
| pushop.pushbranchmap = headssum | pushop.pushbranchmap = headssum | ||||
| newbranches = [ | newbranches = [ | ||||
| branch | branch for branch, heads in headssum.items() if heads[0] is None | ||||
| for branch, heads in pycompat.iteritems(headssum) | |||||
| if heads[0] is None | |||||
| ] | ] | ||||
| # 1. Check for new branches on the remote. | # 1. Check for new branches on the remote. | ||||
| if newbranches and not newbranch: # new branch requires --new-branch | if newbranches and not newbranch: # new branch requires --new-branch | ||||
| branchnames = b', '.join(sorted(newbranches)) | branchnames = b', '.join(sorted(newbranches)) | ||||
| # Calculate how many of the new branches are closed branches | # Calculate how many of the new branches are closed branches | ||||
| closedbranches = set() | closedbranches = set() | ||||
| for tag, heads, tip, isclosed in repo.branchmap().iterbranches(): | for tag, heads, tip, isclosed in repo.branchmap().iterbranches(): | ||||
| if isclosed: | if isclosed: | ||||
| # 2. Find heads that we need not warn about | # 2. Find heads that we need not warn about | ||||
| nowarnheads = _nowarnheads(pushop) | nowarnheads = _nowarnheads(pushop) | ||||
| # 3. Check for new heads. | # 3. Check for new heads. | ||||
| # If there are more heads after the push than before, a suitable | # If there are more heads after the push than before, a suitable | ||||
| # error message, depending on unsynced status, is displayed. | # error message, depending on unsynced status, is displayed. | ||||
| errormsg = None | errormsg = None | ||||
| for branch, heads in sorted(pycompat.iteritems(headssum)): | for branch, heads in sorted(headssum.items()): | ||||
| remoteheads, newheads, unsyncedheads, discardedheads = heads | remoteheads, newheads, unsyncedheads, discardedheads = heads | ||||
| # add unsynced data | # add unsynced data | ||||
| if remoteheads is None: | if remoteheads is None: | ||||
| oldhs = set() | oldhs = set() | ||||
| else: | else: | ||||
| oldhs = set(remoteheads) | oldhs = set(remoteheads) | ||||
| oldhs.update(unsyncedheads) | oldhs.update(unsyncedheads) | ||||
| dhs = None # delta heads, the new heads on branch | dhs = None # delta heads, the new heads on branch | ||||
| self.opts = [] | self.opts = [] | ||||
| self.help = b'' | self.help = b'' | ||||
| self.badalias = None | self.badalias = None | ||||
| self.unknowncmd = False | self.unknowncmd = False | ||||
| self.source = source | self.source = source | ||||
| try: | try: | ||||
| aliases, entry = cmdutil.findcmd(self.name, cmdtable) | aliases, entry = cmdutil.findcmd(self.name, cmdtable) | ||||
| for alias, e in pycompat.iteritems(cmdtable): | for alias, e in cmdtable.items(): | ||||
| if e is entry: | if e is entry: | ||||
| self.cmd = alias | self.cmd = alias | ||||
| break | break | ||||
| self.shadows = True | self.shadows = True | ||||
| except error.UnknownCommand: | except error.UnknownCommand: | ||||
| self.shadows = False | self.shadows = False | ||||
| if not self.definition: | if not self.definition: | ||||
| allowunrelated = b'related' in bundler.capabilities.get( | allowunrelated = b'related' in bundler.capabilities.get( | ||||
| b'checkheads', () | b'checkheads', () | ||||
| ) | ) | ||||
| emptyremote = pushop.pushbranchmap is None | emptyremote = pushop.pushbranchmap is None | ||||
| if not allowunrelated or emptyremote: | if not allowunrelated or emptyremote: | ||||
| bundler.newpart(b'check:heads', data=iter(pushop.remoteheads)) | bundler.newpart(b'check:heads', data=iter(pushop.remoteheads)) | ||||
| else: | else: | ||||
| affected = set() | affected = set() | ||||
| for branch, heads in pycompat.iteritems(pushop.pushbranchmap): | for branch, heads in pushop.pushbranchmap.items(): | ||||
| remoteheads, newheads, unsyncedheads, discardedheads = heads | remoteheads, newheads, unsyncedheads, discardedheads = heads | ||||
| if remoteheads is not None: | if remoteheads is not None: | ||||
| remote = set(remoteheads) | remote = set(remoteheads) | ||||
| affected |= set(discardedheads) & remote | affected |= set(discardedheads) & remote | ||||
| affected |= remote - set(newheads) | affected |= remote - set(newheads) | ||||
| if affected: | if affected: | ||||
| data = iter(sorted(affected)) | data = iter(sorted(affected)) | ||||
| bundler.newpart(b'check:updated-heads', data=data) | bundler.newpart(b'check:updated-heads', data=data) | ||||
| b"'KEY=VALUE' or 'KEY=' format" | b"'KEY=VALUE' or 'KEY=' format" | ||||
| ) | ) | ||||
| raise error.Abort(msg % raw) | raise error.Abort(msg % raw) | ||||
| k, v = raw.split(b'=', 1) | k, v = raw.split(b'=', 1) | ||||
| shellvars[k] = v | shellvars[k] = v | ||||
| part = bundler.newpart(b'pushvars') | part = bundler.newpart(b'pushvars') | ||||
| for key, value in pycompat.iteritems(shellvars): | for key, value in shellvars.items(): | ||||
| part.addparam(key, value, mandatory=False) | part.addparam(key, value, mandatory=False) | ||||
| def _pushbundle2(pushop): | def _pushbundle2(pushop): | ||||
| """push data to the remote using bundle2 | """push data to the remote using bundle2 | ||||
| The only currently supported type of data is changegroup but this will | The only currently supported type of data is changegroup but this will | ||||
| evolve in the future.""" | evolve in the future.""" | ||||
| def find(name): | def find(name): | ||||
| '''return module with given extension name''' | '''return module with given extension name''' | ||||
| mod = None | mod = None | ||||
| try: | try: | ||||
| mod = _extensions[name] | mod = _extensions[name] | ||||
| except KeyError: | except KeyError: | ||||
| for k, v in pycompat.iteritems(_extensions): | for k, v in _extensions.items(): | ||||
| if k.endswith(b'.' + name) or k.endswith(b'/' + name): | if k.endswith(b'.' + name) or k.endswith(b'/' + name): | ||||
| mod = v | mod = v | ||||
| break | break | ||||
| if not mod: | if not mod: | ||||
| raise KeyError(name) | raise KeyError(name) | ||||
| return mod | return mod | ||||
| # attributes set by registrar.command | # attributes set by registrar.command | ||||
| _cmdfuncattrs = (b'norepo', b'optionalrepo', b'inferrepo') | _cmdfuncattrs = (b'norepo', b'optionalrepo', b'inferrepo') | ||||
| def _validatecmdtable(ui, cmdtable): | def _validatecmdtable(ui, cmdtable): | ||||
| """Check if extension commands have required attributes""" | """Check if extension commands have required attributes""" | ||||
| for c, e in pycompat.iteritems(cmdtable): | for c, e in cmdtable.items(): | ||||
| f = e[0] | f = e[0] | ||||
| missing = [a for a in _cmdfuncattrs if not util.safehasattr(f, a)] | missing = [a for a in _cmdfuncattrs if not util.safehasattr(f, a)] | ||||
| if not missing: | if not missing: | ||||
| continue | continue | ||||
| raise error.ProgrammingError( | raise error.ProgrammingError( | ||||
| b'missing attributes: %s' % b', '.join(missing), | b'missing attributes: %s' % b', '.join(missing), | ||||
| hint=b"use @command decorator to register '%s'" % c, | hint=b"use @command decorator to register '%s'" % c, | ||||
| ) | ) | ||||
| local bookmarks. | local bookmarks. | ||||
| """ | """ | ||||
| extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks, | extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks, | ||||
| synopsis, docstring) | synopsis, docstring) | ||||
| ''' | ''' | ||||
| assert callable(wrapper) | assert callable(wrapper) | ||||
| aliases, entry = cmdutil.findcmd(command, table) | aliases, entry = cmdutil.findcmd(command, table) | ||||
| for alias, e in pycompat.iteritems(table): | for alias, e in table.items(): | ||||
| if e is entry: | if e is entry: | ||||
| key = alias | key = alias | ||||
| break | break | ||||
| origfn = entry[0] | origfn = entry[0] | ||||
| wrap = functools.partial( | wrap = functools.partial( | ||||
| util.checksignature(wrapper), util.checksignature(origfn) | util.checksignature(wrapper), util.checksignature(origfn) | ||||
| ) | ) | ||||
| else: | else: | ||||
| name = e | name = e | ||||
| path = os.path.join(extpath, e, b'__init__.py') | path = os.path.join(extpath, e, b'__init__.py') | ||||
| if not os.path.exists(path): | if not os.path.exists(path): | ||||
| continue | continue | ||||
| if name in exts or name in _order or name == b'__init__': | if name in exts or name in _order or name == b'__init__': | ||||
| continue | continue | ||||
| exts[name] = path | exts[name] = path | ||||
| for name, path in pycompat.iteritems(_disabledextensions): | for name, path in _disabledextensions.items(): | ||||
| # If no path was provided for a disabled extension (e.g. "color=!"), | # If no path was provided for a disabled extension (e.g. "color=!"), | ||||
| # don't replace the path we already found by the scan above. | # don't replace the path we already found by the scan above. | ||||
| if path: | if path: | ||||
| exts[name] = path | exts[name] = path | ||||
| return exts | return exts | ||||
| def _moduledoc(file): | def _moduledoc(file): | ||||
| def disabled(): | def disabled(): | ||||
| '''find disabled extensions from hgext. returns a dict of {name: desc}''' | '''find disabled extensions from hgext. returns a dict of {name: desc}''' | ||||
| try: | try: | ||||
| from hgext import __index__ # pytype: disable=import-error | from hgext import __index__ # pytype: disable=import-error | ||||
| return { | return { | ||||
| name: gettext(desc) | name: gettext(desc) | ||||
| for name, desc in pycompat.iteritems(__index__.docs) | for name, desc in __index__.docs.items() | ||||
| if name not in _order | if name not in _order | ||||
| } | } | ||||
| except (ImportError, AttributeError): | except (ImportError, AttributeError): | ||||
| pass | pass | ||||
| paths = _disabledpaths() | paths = _disabledpaths() | ||||
| if not paths: | if not paths: | ||||
| return {} | return {} | ||||
| exts = {} | exts = {} | ||||
| for name, path in pycompat.iteritems(paths): | for name, path in paths.items(): | ||||
| doc = _disabledhelp(path) | doc = _disabledhelp(path) | ||||
| if doc and name != b'__index__': | if doc and name != b'__index__': | ||||
| exts[name] = doc.splitlines()[0] | exts[name] = doc.splitlines()[0] | ||||
| return exts | return exts | ||||
| def disabled_help(name): | def disabled_help(name): | ||||
| ext = None | ext = None | ||||
| # first, search for an extension with the same name as the command | # first, search for an extension with the same name as the command | ||||
| path = paths.pop(cmd, None) | path = paths.pop(cmd, None) | ||||
| if path: | if path: | ||||
| ext = _finddisabledcmd(ui, cmd, cmd, path, strict=strict) | ext = _finddisabledcmd(ui, cmd, cmd, path, strict=strict) | ||||
| if not ext: | if not ext: | ||||
| # otherwise, interrogate each extension until there's a match | # otherwise, interrogate each extension until there's a match | ||||
| for name, path in pycompat.iteritems(paths): | for name, path in paths.items(): | ||||
| ext = _finddisabledcmd(ui, cmd, name, path, strict=strict) | ext = _finddisabledcmd(ui, cmd, name, path, strict=strict) | ||||
| if ext: | if ext: | ||||
| break | break | ||||
| if ext: | if ext: | ||||
| return ext | return ext | ||||
| raise error.UnknownCommand(cmd) | raise error.UnknownCommand(cmd) | ||||
| def enabled(shortname=True): | def enabled(shortname=True): | ||||
| '''return a dict of {name: desc} of extensions''' | '''return a dict of {name: desc} of extensions''' | ||||
| exts = {} | exts = {} | ||||
| for ename, ext in extensions(): | for ename, ext in extensions(): | ||||
| doc = gettext(ext.__doc__) or _(b'(no help text available)') | doc = gettext(ext.__doc__) or _(b'(no help text available)') | ||||
| assert doc is not None # help pytype | assert doc is not None # help pytype | ||||
| if shortname: | if shortname: | ||||
| ename = ename.split(b'.')[-1] | ename = ename.split(b'.')[-1] | ||||
| exts[ename] = doc.splitlines()[0].strip() | exts[ename] = doc.splitlines()[0].strip() | ||||
| return exts | return exts | ||||
| def notloaded(): | def notloaded(): | ||||
| '''return short names of extensions that failed to load''' | '''return short names of extensions that failed to load''' | ||||
| return [ | return [name for name, mod in _extensions.items() if mod is None] | ||||
| name for name, mod in pycompat.iteritems(_extensions) if mod is None | |||||
| ] | |||||
| def moduleversion(module): | def moduleversion(module): | ||||
| '''return version information from given module as a string''' | '''return version information from given module as a string''' | ||||
| if util.safehasattr(module, b'getversion') and callable(module.getversion): | if util.safehasattr(module, b'getversion') and callable(module.getversion): | ||||
| try: | try: | ||||
| version = module.getversion() | version = module.getversion() | ||||
| except Exception: | except Exception: | ||||
| # Copyright 2012 Logilab SA <contact@logilab.fr> | # Copyright 2012 Logilab SA <contact@logilab.fr> | ||||
| # Pierre-Yves David <pierre-yves.david@ens-lyon.org> | # Pierre-Yves David <pierre-yves.david@ens-lyon.org> | ||||
| # Octobus <contact@octobus.net> | # Octobus <contact@octobus.net> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| ##################################################################### | ##################################################################### | ||||
| ### Extension helper ### | ### Extension helper ### | ||||
| ##################################################################### | ##################################################################### | ||||
| from . import ( | from . import ( | ||||
| commands, | commands, | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| pycompat, | |||||
| registrar, | registrar, | ||||
| ) | ) | ||||
| from hgdemandimport import tracing | from hgdemandimport import tracing | ||||
| class exthelper(object): | class exthelper(object): | ||||
| """Helper for modular extension setup | """Helper for modular extension setup | ||||
| self._repocallables.extend(other._repocallables) | self._repocallables.extend(other._repocallables) | ||||
| self.filesetpredicate._merge(other.filesetpredicate) | self.filesetpredicate._merge(other.filesetpredicate) | ||||
| self.revsetpredicate._merge(other.revsetpredicate) | self.revsetpredicate._merge(other.revsetpredicate) | ||||
| self.templatekeyword._merge(other.templatekeyword) | self.templatekeyword._merge(other.templatekeyword) | ||||
| self._commandwrappers.extend(other._commandwrappers) | self._commandwrappers.extend(other._commandwrappers) | ||||
| self._extcommandwrappers.extend(other._extcommandwrappers) | self._extcommandwrappers.extend(other._extcommandwrappers) | ||||
| self._functionwrappers.extend(other._functionwrappers) | self._functionwrappers.extend(other._functionwrappers) | ||||
| self.cmdtable.update(other.cmdtable) | self.cmdtable.update(other.cmdtable) | ||||
| for section, items in pycompat.iteritems(other.configtable): | for section, items in other.configtable.items(): | ||||
| if section in self.configtable: | if section in self.configtable: | ||||
| self.configtable[section].update(items) | self.configtable[section].update(items) | ||||
| else: | else: | ||||
| self.configtable[section] = items | self.configtable[section] = items | ||||
| def finaluisetup(self, ui): | def finaluisetup(self, ui): | ||||
| """Method to be used as the extension uisetup | """Method to be used as the extension uisetup | ||||
| def _workingpath(repo, ctx): | def _workingpath(repo, ctx): | ||||
| return repo.wjoin(ctx.path()) | return repo.wjoin(ctx.path()) | ||||
| def loadinternalmerge(ui, extname, registrarobj): | def loadinternalmerge(ui, extname, registrarobj): | ||||
| """Load internal merge tool from specified registrarobj""" | """Load internal merge tool from specified registrarobj""" | ||||
| for name, func in pycompat.iteritems(registrarobj._table): | for name, func in registrarobj._table.items(): | ||||
| fullname = b':' + name | fullname = b':' + name | ||||
| internals[fullname] = func | internals[fullname] = func | ||||
| internals[b'internal:' + name] = func | internals[b'internal:' + name] = func | ||||
| internalsdoc[fullname] = func | internalsdoc[fullname] = func | ||||
| capabilities = sorted([k for k, v in func.capabilities.items() if v]) | capabilities = sorted([k for k, v in func.capabilities.items() if v]) | ||||
| if capabilities: | if capabilities: | ||||
| capdesc = b" (actual capabilities: %s)" % b', '.join( | capdesc = b" (actual capabilities: %s)" % b', '.join( | ||||
| tree = filesetlang.analyze(tree) | tree = filesetlang.analyze(tree) | ||||
| tree = filesetlang.optimize(tree) | tree = filesetlang.optimize(tree) | ||||
| mctx = matchctx(ctx.p1(), ctx, cwd, badfn=badfn) | mctx = matchctx(ctx.p1(), ctx, cwd, badfn=badfn) | ||||
| return getmatch(mctx, tree) | return getmatch(mctx, tree) | ||||
| def loadpredicate(ui, extname, registrarobj): | def loadpredicate(ui, extname, registrarobj): | ||||
| """Load fileset predicates from specified registrarobj""" | """Load fileset predicates from specified registrarobj""" | ||||
| for name, func in pycompat.iteritems(registrarobj._table): | for name, func in registrarobj._table.items(): | ||||
| symbols[name] = func | symbols[name] = func | ||||
| # tell hggettext to extract docstrings from these functions: | # tell hggettext to extract docstrings from these functions: | ||||
| i18nfunctions = symbols.values() | i18nfunctions = symbols.values() | ||||
| def _showitem(self): | def _showitem(self): | ||||
| self._data.append(self._item) | self._data.append(self._item) | ||||
| def _iteritems(data): | def _iteritems(data): | ||||
| '''iterate key-value pairs in stable order''' | '''iterate key-value pairs in stable order''' | ||||
| if isinstance(data, dict): | if isinstance(data, dict): | ||||
| return sorted(pycompat.iteritems(data)) | return sorted(data.items()) | ||||
| return data | return data | ||||
| class _plainconverter(object): | class _plainconverter(object): | ||||
| '''convert non-primitive data types to text''' | '''convert non-primitive data types to text''' | ||||
| storecontext = False | storecontext = False | ||||
| TOPIC_CATEGORY_NONE: b'Uncategorized topics', | TOPIC_CATEGORY_NONE: b'Uncategorized topics', | ||||
| } | } | ||||
| def listexts(header, exts, indent=1, showdeprecated=False): | def listexts(header, exts, indent=1, showdeprecated=False): | ||||
| '''return a text listing of the given extensions''' | '''return a text listing of the given extensions''' | ||||
| rst = [] | rst = [] | ||||
| if exts: | if exts: | ||||
| for name, desc in sorted(pycompat.iteritems(exts)): | for name, desc in sorted(exts.items()): | ||||
| if not showdeprecated and any(w in desc for w in _exclkeywords): | if not showdeprecated and any(w in desc for w in _exclkeywords): | ||||
| continue | continue | ||||
| rst.append(b'%s:%s: %s\n' % (b' ' * indent, name, desc)) | rst.append(b'%s:%s: %s\n' % (b' ' * indent, name, desc)) | ||||
| if rst: | if rst: | ||||
| rst.insert(0, b'\n%s\n\n' % header) | rst.insert(0, b'\n%s\n\n' % header) | ||||
| return rst | return rst | ||||
| if ( | if ( | ||||
| sum(map(lowercontains, names)) | sum(map(lowercontains, names)) | ||||
| or lowercontains(header) | or lowercontains(header) | ||||
| or (callable(doc) and lowercontains(doc(ui))) | or (callable(doc) and lowercontains(doc(ui))) | ||||
| ): | ): | ||||
| name = names[0] | name = names[0] | ||||
| if not filtertopic(ui, name): | if not filtertopic(ui, name): | ||||
| results[b'topics'].append((names[0], header)) | results[b'topics'].append((names[0], header)) | ||||
| for cmd, entry in pycompat.iteritems(commands.table): | for cmd, entry in commands.table.items(): | ||||
| if len(entry) == 3: | if len(entry) == 3: | ||||
| summary = entry[2] | summary = entry[2] | ||||
| else: | else: | ||||
| summary = b'' | summary = b'' | ||||
| # translate docs *before* searching there | # translate docs *before* searching there | ||||
| func = entry[0] | func = entry[0] | ||||
| docs = _(pycompat.getdoc(func)) or b'' | docs = _(pycompat.getdoc(func)) or b'' | ||||
| if kw in cmd or lowercontains(summary) or lowercontains(docs): | if kw in cmd or lowercontains(summary) or lowercontains(docs): | ||||
| def _getcategorizedhelpcmds(ui, cmdtable, name, select=None): | def _getcategorizedhelpcmds(ui, cmdtable, name, select=None): | ||||
| # Category -> list of commands | # Category -> list of commands | ||||
| cats = {} | cats = {} | ||||
| # Command -> short description | # Command -> short description | ||||
| h = {} | h = {} | ||||
| # Command -> string showing synonyms | # Command -> string showing synonyms | ||||
| syns = {} | syns = {} | ||||
| for c, e in pycompat.iteritems(cmdtable): | for c, e in cmdtable.items(): | ||||
| fs = cmdutil.parsealiases(c) | fs = cmdutil.parsealiases(c) | ||||
| f = fs[0] | f = fs[0] | ||||
| syns[f] = fs | syns[f] = fs | ||||
| func = e[0] | func = e[0] | ||||
| if select and not select(f): | if select and not select(f): | ||||
| continue | continue | ||||
| doc = pycompat.getdoc(func) | doc = pycompat.getdoc(func) | ||||
| if filtercmd(ui, f, func, name, doc): | if filtercmd(ui, f, func, name, doc): | ||||
| req.qsparams.add(b'file', a) | req.qsparams.add(b'file', a) | ||||
| ua = req.headers.get(b'User-Agent', b'') | ua = req.headers.get(b'User-Agent', b'') | ||||
| if cmd == b'rev' and b'mercurial' in ua: | if cmd == b'rev' and b'mercurial' in ua: | ||||
| req.qsparams[b'style'] = b'raw' | req.qsparams[b'style'] = b'raw' | ||||
| if cmd == b'archive': | if cmd == b'archive': | ||||
| fn = req.qsparams[b'node'] | fn = req.qsparams[b'node'] | ||||
| for type_, spec in pycompat.iteritems(webutil.archivespecs): | for type_, spec in webutil.archivespecs.items(): | ||||
| ext = spec[2] | ext = spec[2] | ||||
| if fn.endswith(ext): | if fn.endswith(ext): | ||||
| req.qsparams[b'node'] = fn[: -len(ext)] | req.qsparams[b'node'] = fn[: -len(ext)] | ||||
| req.qsparams[b'type'] = type_ | req.qsparams[b'type'] = type_ | ||||
| else: | else: | ||||
| cmd = req.qsparams.get(b'cmd', b'') | cmd = req.qsparams.get(b'cmd', b'') | ||||
| # process the web interface request | # process the web interface request | ||||
| vals = self._items[key] | vals = self._items[key] | ||||
| if len(vals) > 1: | if len(vals) > 1: | ||||
| raise KeyError(b'multiple values for %r' % key) | raise KeyError(b'multiple values for %r' % key) | ||||
| return vals[0] | return vals[0] | ||||
| def asdictoflists(self): | def asdictoflists(self): | ||||
| return {k: list(v) for k, v in pycompat.iteritems(self._items)} | return {k: list(v) for k, v in self._items.items()} | ||||
| @attr.s(frozen=True) | @attr.s(frozen=True) | ||||
| class parsedrequest(object): | class parsedrequest(object): | ||||
| """Represents a parsed WSGI request. | """Represents a parsed WSGI request. | ||||
| Contains both parsed parameters as well as a handle on the input stream. | Contains both parsed parameters as well as a handle on the input stream. | ||||
| """ | """ | ||||
| if pycompat.iswindows: | if pycompat.iswindows: | ||||
| # This is what mercurial.encoding does for os.environ on | # This is what mercurial.encoding does for os.environ on | ||||
| # Windows. | # Windows. | ||||
| return encoding.strtolocal(s) | return encoding.strtolocal(s) | ||||
| else: | else: | ||||
| # This is what is documented to be used for os.environ on Unix. | # This is what is documented to be used for os.environ on Unix. | ||||
| return pycompat.fsencode(s) | return pycompat.fsencode(s) | ||||
| env = {tobytes(k): tobytes(v) for k, v in pycompat.iteritems(env)} | env = {tobytes(k): tobytes(v) for k, v in env.items()} | ||||
| # Some hosting solutions are emulating hgwebdir, and dispatching directly | # Some hosting solutions are emulating hgwebdir, and dispatching directly | ||||
| # to an hgweb instance using this environment variable. This was always | # to an hgweb instance using this environment variable. This was always | ||||
| # checked prior to d7fd203e36cc; keep doing so to avoid breaking them. | # checked prior to d7fd203e36cc; keep doing so to avoid breaking them. | ||||
| if not reponame: | if not reponame: | ||||
| reponame = env.get(b'REPO_NAME') | reponame = env.get(b'REPO_NAME') | ||||
| if altbaseurl: | if altbaseurl: | ||||
| qsparams = multidict() | qsparams = multidict() | ||||
| for k, v in util.urlreq.parseqsl(querystring, keep_blank_values=True): | for k, v in util.urlreq.parseqsl(querystring, keep_blank_values=True): | ||||
| qsparams.add(k, v) | qsparams.add(k, v) | ||||
| # HTTP_* keys contain HTTP request headers. The Headers structure should | # HTTP_* keys contain HTTP request headers. The Headers structure should | ||||
| # perform case normalization for us. We just rewrite underscore to dash | # perform case normalization for us. We just rewrite underscore to dash | ||||
| # so keys match what likely went over the wire. | # so keys match what likely went over the wire. | ||||
| headers = [] | headers = [] | ||||
| for k, v in pycompat.iteritems(env): | for k, v in env.items(): | ||||
| if k.startswith(b'HTTP_'): | if k.startswith(b'HTTP_'): | ||||
| headers.append((k[len(b'HTTP_') :].replace(b'_', b'-'), v)) | headers.append((k[len(b'HTTP_') :].replace(b'_', b'-'), v)) | ||||
| from . import wsgiheaders # avoid cycle | from . import wsgiheaders # avoid cycle | ||||
| headers = wsgiheaders.Headers(headers) | headers = wsgiheaders.Headers(headers) | ||||
| # This is kind of a lie because the HTTP header wasn't explicitly | # This is kind of a lie because the HTTP header wasn't explicitly | ||||
| dirs = {} | dirs = {} | ||||
| parity = paritygen(web.stripecount) | parity = paritygen(web.stripecount) | ||||
| if path and path[-1:] != b"/": | if path and path[-1:] != b"/": | ||||
| path += b"/" | path += b"/" | ||||
| l = len(path) | l = len(path) | ||||
| abspath = b"/" + path | abspath = b"/" + path | ||||
| for full, n in pycompat.iteritems(mf): | for full, n in mf.items(): | ||||
| # the virtual path (working copy path) used for the full | # the virtual path (working copy path) used for the full | ||||
| # (repository) path | # (repository) path | ||||
| f = decodepath(full) | f = decodepath(full) | ||||
| if f[:l] != path: | if f[:l] != path: | ||||
| continue | continue | ||||
| remain = f[l:] | remain = f[l:] | ||||
| elements = remain.split(b'/') | elements = remain.split(b'/') | ||||
| def topics(context): | def topics(context): | ||||
| for h in helpmod.helptable: | for h in helpmod.helptable: | ||||
| entries, summary, _doc = h[0:3] | entries, summary, _doc = h[0:3] | ||||
| yield {b'topic': entries[0], b'summary': summary} | yield {b'topic': entries[0], b'summary': summary} | ||||
| early, other = [], [] | early, other = [], [] | ||||
| primary = lambda s: s.partition(b'|')[0] | primary = lambda s: s.partition(b'|')[0] | ||||
| for c, e in pycompat.iteritems(commands.table): | for c, e in commands.table.items(): | ||||
| doc = _getdoc(e) | doc = _getdoc(e) | ||||
| if b'DEPRECATED' in doc or c.startswith(b'debug'): | if b'DEPRECATED' in doc or c.startswith(b'debug'): | ||||
| continue | continue | ||||
| cmd = primary(c) | cmd = primary(c) | ||||
| if getattr(e[0], 'helpbasic', False): | if getattr(e[0], 'helpbasic', False): | ||||
| early.append((cmd, doc)) | early.append((cmd, doc)) | ||||
| else: | else: | ||||
| other.append((cmd, doc)) | other.append((cmd, doc)) | ||||
| ) | ) | ||||
| ) | ) | ||||
| def archivelist(ui, nodeid, url=None): | def archivelist(ui, nodeid, url=None): | ||||
| allowed = ui.configlist(b'web', b'allow-archive', untrusted=True) | allowed = ui.configlist(b'web', b'allow-archive', untrusted=True) | ||||
| archives = [] | archives = [] | ||||
| for typ, spec in pycompat.iteritems(archivespecs): | for typ, spec in archivespecs.items(): | ||||
| if typ in allowed or ui.configbool( | if typ in allowed or ui.configbool( | ||||
| b'web', b'allow' + typ, untrusted=True | b'web', b'allow' + typ, untrusted=True | ||||
| ): | ): | ||||
| archives.append( | archives.append( | ||||
| { | { | ||||
| b'type': typ, | b'type': typ, | ||||
| b'extension': spec[2], | b'extension': spec[2], | ||||
| b'node': nodeid, | b'node': nodeid, | ||||
| raise error.ParseError(_(b'not comparable')) | raise error.ParseError(_(b'not comparable')) | ||||
| def filter(self, context, mapping, select): | def filter(self, context, mapping, select): | ||||
| # implement if necessary | # implement if necessary | ||||
| raise error.ParseError(_(b'not filterable')) | raise error.ParseError(_(b'not filterable')) | ||||
| def itermaps(self, context): | def itermaps(self, context): | ||||
| separator = self._start | separator = self._start | ||||
| for key, value in sorted(pycompat.iteritems(self._vars)): | for key, value in sorted(self._vars.items()): | ||||
| yield { | yield { | ||||
| b'name': key, | b'name': key, | ||||
| b'value': pycompat.bytestr(value), | b'value': pycompat.bytestr(value), | ||||
| b'separator': separator, | b'separator': separator, | ||||
| } | } | ||||
| separator = b'&' | separator = b'&' | ||||
| def join(self, context, mapping, sep): | def join(self, context, mapping, sep): | ||||
| from . import common | from . import common | ||||
| def launch(application): | def launch(application): | ||||
| procutil.setbinary(procutil.stdin) | procutil.setbinary(procutil.stdin) | ||||
| procutil.setbinary(procutil.stdout) | procutil.setbinary(procutil.stdout) | ||||
| environ = dict(pycompat.iteritems(os.environ)) # re-exports | environ = dict(os.environ.items()) # re-exports | ||||
| environ.setdefault('PATH_INFO', '') | environ.setdefault('PATH_INFO', '') | ||||
| if environ.get('SERVER_SOFTWARE', '').startswith('Microsoft-IIS'): | if environ.get('SERVER_SOFTWARE', '').startswith('Microsoft-IIS'): | ||||
| # IIS includes script_name in PATH_INFO | # IIS includes script_name in PATH_INFO | ||||
| scriptname = environ['SCRIPT_NAME'] | scriptname = environ['SCRIPT_NAME'] | ||||
| if environ['PATH_INFO'].startswith(scriptname): | if environ['PATH_INFO'].startswith(scriptname): | ||||
| environ['PATH_INFO'] = environ['PATH_INFO'][len(scriptname) :] | environ['PATH_INFO'] = environ['PATH_INFO'][len(scriptname) :] | ||||
| stdin = procutil.stdin | stdin = procutil.stdin | ||||
| plain = ui.plain() | plain = ui.plain() | ||||
| else: | else: | ||||
| plain = ui.configbool(b'hooks', b'%s:run-with-plain' % name) | plain = ui.configbool(b'hooks', b'%s:run-with-plain' % name) | ||||
| if plain: | if plain: | ||||
| env[b'HGPLAIN'] = b'1' | env[b'HGPLAIN'] = b'1' | ||||
| else: | else: | ||||
| env[b'HGPLAIN'] = b'' | env[b'HGPLAIN'] = b'' | ||||
| for k, v in pycompat.iteritems(args): | for k, v in args.items(): | ||||
| # transaction changes can accumulate MBs of data, so skip it | # transaction changes can accumulate MBs of data, so skip it | ||||
| # for external hooks | # for external hooks | ||||
| if k == b'changes': | if k == b'changes': | ||||
| continue | continue | ||||
| if callable(v): | if callable(v): | ||||
| v = v() | v = v() | ||||
| if isinstance(v, (dict, list)): | if isinstance(v, (dict, list)): | ||||
| v = stringutil.pprint(v) | v = stringutil.pprint(v) | ||||
| val = util.expandpath(val) | val = util.expandpath(val) | ||||
| gdict[setting] = val | gdict[setting] = val | ||||
| # Find the best match | # Find the best match | ||||
| scheme, hostpath = uri.split(b'://', 1) | scheme, hostpath = uri.split(b'://', 1) | ||||
| bestuser = None | bestuser = None | ||||
| bestlen = 0 | bestlen = 0 | ||||
| bestauth = None | bestauth = None | ||||
| for group, auth in pycompat.iteritems(groups): | for group, auth in groups.items(): | ||||
| if user and user != auth.get(b'username', user): | if user and user != auth.get(b'username', user): | ||||
| # If a username was set in the URI, the entry username | # If a username was set in the URI, the entry username | ||||
| # must either match it or be unset | # must either match it or be unset | ||||
| continue | continue | ||||
| prefix = auth.get(b'prefix') | prefix = auth.get(b'prefix') | ||||
| if not prefix: | if not prefix: | ||||
| continue | continue | ||||
| def tags(self): | def tags(self): | ||||
| '''return a mapping of tag to node''' | '''return a mapping of tag to node''' | ||||
| t = {} | t = {} | ||||
| if self.changelog.filteredrevs: | if self.changelog.filteredrevs: | ||||
| tags, tt = self._findtags() | tags, tt = self._findtags() | ||||
| else: | else: | ||||
| tags = self._tagscache.tags | tags = self._tagscache.tags | ||||
| rev = self.changelog.rev | rev = self.changelog.rev | ||||
| for k, v in pycompat.iteritems(tags): | for k, v in tags.items(): | ||||
| try: | try: | ||||
| # ignore tags to unknown nodes | # ignore tags to unknown nodes | ||||
| rev(v) | rev(v) | ||||
| t[k] = v | t[k] = v | ||||
| except (error.LookupError, ValueError): | except (error.LookupError, ValueError): | ||||
| pass | pass | ||||
| return t | return t | ||||
| tagsmod.readlocaltags(self.ui, self, alltags, tagtypes) | tagsmod.readlocaltags(self.ui, self, alltags, tagtypes) | ||||
| # Build the return dicts. Have to re-encode tag names because | # Build the return dicts. Have to re-encode tag names because | ||||
| # the tags module always uses UTF-8 (in order not to lose info | # the tags module always uses UTF-8 (in order not to lose info | ||||
| # writing to the cache), but the rest of Mercurial wants them in | # writing to the cache), but the rest of Mercurial wants them in | ||||
| # local encoding. | # local encoding. | ||||
| tags = {} | tags = {} | ||||
| for (name, (node, hist)) in pycompat.iteritems(alltags): | for (name, (node, hist)) in alltags.items(): | ||||
| if node != self.nullid: | if node != self.nullid: | ||||
| tags[encoding.tolocal(name)] = node | tags[encoding.tolocal(name)] = node | ||||
| tags[b'tip'] = self.changelog.tip() | tags[b'tip'] = self.changelog.tip() | ||||
| tagtypes = { | tagtypes = { | ||||
| encoding.tolocal(name): value | encoding.tolocal(name): value for (name, value) in tagtypes.items() | ||||
| for (name, value) in pycompat.iteritems(tagtypes) | |||||
| } | } | ||||
| return (tags, tagtypes) | return (tags, tagtypes) | ||||
| def tagtype(self, tagname): | def tagtype(self, tagname): | ||||
| """ | """ | ||||
| return the type of the given tag. result can be: | return the type of the given tag. result can be: | ||||
| 'local' : a local tag | 'local' : a local tag | ||||
| self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)] | self._tagscache.tagslist = [(t, n) for r, t, n in sorted(l)] | ||||
| return self._tagscache.tagslist | return self._tagscache.tagslist | ||||
| def nodetags(self, node): | def nodetags(self, node): | ||||
| '''return the tags associated with a node''' | '''return the tags associated with a node''' | ||||
| if not self._tagscache.nodetagscache: | if not self._tagscache.nodetagscache: | ||||
| nodetagscache = {} | nodetagscache = {} | ||||
| for t, n in pycompat.iteritems(self._tagscache.tags): | for t, n in self._tagscache.tags.items(): | ||||
| nodetagscache.setdefault(n, []).append(t) | nodetagscache.setdefault(n, []).append(t) | ||||
| for tags in pycompat.itervalues(nodetagscache): | for tags in pycompat.itervalues(nodetagscache): | ||||
| tags.sort() | tags.sort() | ||||
| self._tagscache.nodetagscache = nodetagscache | self._tagscache.nodetagscache = nodetagscache | ||||
| return self._tagscache.nodetagscache.get(node, []) | return self._tagscache.nodetagscache.get(node, []) | ||||
| def nodebookmarks(self, node): | def nodebookmarks(self, node): | ||||
| """return the list of bookmarks pointing to the specified node""" | """return the list of bookmarks pointing to the specified node""" | ||||
| if filter not in self._filterpats: | if filter not in self._filterpats: | ||||
| l = [] | l = [] | ||||
| for pat, cmd in self.ui.configitems(filter): | for pat, cmd in self.ui.configitems(filter): | ||||
| if cmd == b'!': | if cmd == b'!': | ||||
| continue | continue | ||||
| mf = matchmod.match(self.root, b'', [pat]) | mf = matchmod.match(self.root, b'', [pat]) | ||||
| fn = None | fn = None | ||||
| params = cmd | params = cmd | ||||
| for name, filterfn in pycompat.iteritems(self._datafilters): | for name, filterfn in self._datafilters.items(): | ||||
| if cmd.startswith(name): | if cmd.startswith(name): | ||||
| fn = filterfn | fn = filterfn | ||||
| params = cmd[len(name) :].lstrip() | params = cmd[len(name) :].lstrip() | ||||
| break | break | ||||
| if not fn: | if not fn: | ||||
| fn = lambda s, c, **kwargs: procutil.filter(s, c) | fn = lambda s, c, **kwargs: procutil.filter(s, c) | ||||
| fn.__name__ = 'commandfilter' | fn.__name__ = 'commandfilter' | ||||
| # Wrap old filters not supporting keyword arguments | # Wrap old filters not supporting keyword arguments | ||||
| # branches are shown first before any other names due to backwards | # branches are shown first before any other names due to backwards | ||||
| # compatibility | # compatibility | ||||
| branch = ctx.branch() | branch = ctx.branch() | ||||
| # don't show the default branch name | # don't show the default branch name | ||||
| if branch != b'default': | if branch != b'default': | ||||
| self.ui.write(columns[b'branch'] % branch, label=b'log.branch') | self.ui.write(columns[b'branch'] % branch, label=b'log.branch') | ||||
| for nsname, ns in pycompat.iteritems(self.repo.names): | for nsname, ns in self.repo.names.items(): | ||||
| # branches has special logic already handled above, so here we just | # branches has special logic already handled above, so here we just | ||||
| # skip it | # skip it | ||||
| if nsname == b'branches': | if nsname == b'branches': | ||||
| continue | continue | ||||
| # we will use the templatename as the color name since those two | # we will use the templatename as the color name since those two | ||||
| # should be the same | # should be the same | ||||
| for name in ns.names(self.repo, changenode): | for name in ns.names(self.repo, changenode): | ||||
| self.ui.write(ns.logfmt % name, label=b'log.%s' % ns.colorname) | self.ui.write(ns.logfmt % name, label=b'log.%s' % ns.colorname) | ||||
| matchargs.append(b'i:' + p) | matchargs.append(b'i:' + p) | ||||
| for p in wopts.exclude_pats: | for p in wopts.exclude_pats: | ||||
| matchargs.append(b'x:' + p) | matchargs.append(b'x:' + p) | ||||
| opts[b'_matchfiles'] = matchargs | opts[b'_matchfiles'] = matchargs | ||||
| elif wopts.filter_revisions_by_pats and not wopts.follow: | elif wopts.filter_revisions_by_pats and not wopts.follow: | ||||
| opts[b'_patslog'] = list(wopts.pats) | opts[b'_patslog'] = list(wopts.pats) | ||||
| expr = [] | expr = [] | ||||
| for op, val in sorted(pycompat.iteritems(opts)): | for op, val in sorted(opts.items()): | ||||
| if not val: | if not val: | ||||
| continue | continue | ||||
| revop, listop = _opt2logrevset[op] | revop, listop = _opt2logrevset[op] | ||||
| if revop and b'%' not in revop: | if revop and b'%' not in revop: | ||||
| expr.append(revop) | expr.append(revop) | ||||
| elif not listop: | elif not listop: | ||||
| expr.append(revsetlang.formatspec(revop, val)) | expr.append(revsetlang.formatspec(revop, val)) | ||||
| else: | else: | ||||
| # logexchange.py | # logexchange.py | ||||
| # | # | ||||
| # Copyright 2017 Augie Fackler <raf@durin42.com> | # Copyright 2017 Augie Fackler <raf@durin42.com> | ||||
| # Copyright 2017 Sean Farley <sean@farley.io> | # Copyright 2017 Sean Farley <sean@farley.io> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from .node import hex | from .node import hex | ||||
| from . import ( | from . import ( | ||||
| pycompat, | |||||
| util, | util, | ||||
| vfs as vfsmod, | vfs as vfsmod, | ||||
| ) | ) | ||||
| from .utils import ( | from .utils import ( | ||||
| urlutil, | urlutil, | ||||
| ) | ) | ||||
| # directory name in .hg/ in which remotenames files will be present | # directory name in .hg/ in which remotenames files will be present | ||||
| f.write(b'0\n\n') | f.write(b'0\n\n') | ||||
| olddata = set(readremotenamefile(repo, nametype)) | olddata = set(readremotenamefile(repo, nametype)) | ||||
| # re-save the data from a different remote than this one. | # re-save the data from a different remote than this one. | ||||
| for node, oldpath, rname in sorted(olddata): | for node, oldpath, rname in sorted(olddata): | ||||
| if oldpath != remotepath: | if oldpath != remotepath: | ||||
| f.write(b'%s\0%s\0%s\n' % (node, oldpath, rname)) | f.write(b'%s\0%s\0%s\n' % (node, oldpath, rname)) | ||||
| for name, node in sorted(pycompat.iteritems(names)): | for name, node in sorted(names.items()): | ||||
| if nametype == b"branches": | if nametype == b"branches": | ||||
| for n in node: | for n in node: | ||||
| f.write(b'%s\0%s\0%s\n' % (n, remotepath, name)) | f.write(b'%s\0%s\0%s\n' % (n, remotepath, name)) | ||||
| elif nametype == b"bookmarks": | elif nametype == b"bookmarks": | ||||
| if node: | if node: | ||||
| f.write(b'%s\0%s\0%s\n' % (node, remotepath, name)) | f.write(b'%s\0%s\0%s\n' % (node, remotepath, name)) | ||||
| f.close() | f.close() | ||||
| # remove them here otherwise we would require the user | # remove them here otherwise we would require the user | ||||
| # to issue a pull to refresh the storage | # to issue a pull to refresh the storage | ||||
| bmap = {} | bmap = {} | ||||
| repo = localrepo.unfiltered() | repo = localrepo.unfiltered() | ||||
| with remoterepo.commandexecutor() as e: | with remoterepo.commandexecutor() as e: | ||||
| branchmap = e.callcommand(b'branchmap', {}).result() | branchmap = e.callcommand(b'branchmap', {}).result() | ||||
| for branch, nodes in pycompat.iteritems(branchmap): | for branch, nodes in branchmap.items(): | ||||
| bmap[branch] = [] | bmap[branch] = [] | ||||
| for node in nodes: | for node in nodes: | ||||
| if node in repo and not repo[node].obsolete(): | if node in repo and not repo[node].obsolete(): | ||||
| bmap[branch].append(hex(node)) | bmap[branch].append(hex(node)) | ||||
| saveremotenames(localrepo, remotepath, bmap, bookmarks) | saveremotenames(localrepo, remotepath, bmap, bookmarks) | ||||
| import _lsprof | import _lsprof | ||||
| import sys | import sys | ||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from . import pycompat | |||||
| Profiler = _lsprof.Profiler | Profiler = _lsprof.Profiler | ||||
| # PyPy doesn't expose profiler_entry from the module. | # PyPy doesn't expose profiler_entry from the module. | ||||
| profiler_entry = getattr(_lsprof, 'profiler_entry', None) | profiler_entry = getattr(_lsprof, 'profiler_entry', None) | ||||
| __all__ = [b'profile', b'Stats'] | __all__ = [b'profile', b'Stats'] | ||||
| def label(code): | def label(code): | ||||
| if isinstance(code, str): | if isinstance(code, str): | ||||
| if sys.version_info.major >= 3: | if sys.version_info.major >= 3: | ||||
| code = code.encode('latin-1') | code = code.encode('latin-1') | ||||
| return code | return code | ||||
| try: | try: | ||||
| mname = _fn2mod[code.co_filename] | mname = _fn2mod[code.co_filename] | ||||
| except KeyError: | except KeyError: | ||||
| for k, v in list(pycompat.iteritems(sys.modules)): | for k, v in list(sys.modules.items()): | ||||
| if v is None: | if v is None: | ||||
| continue | continue | ||||
| if not isinstance(getattr(v, '__file__', None), str): | if not isinstance(getattr(v, '__file__', None), str): | ||||
| continue | continue | ||||
| if v.__file__.startswith(code.co_filename): | if v.__file__.startswith(code.co_filename): | ||||
| mname = _fn2mod[code.co_filename] = k | mname = _fn2mod[code.co_filename] = k | ||||
| break | break | ||||
| else: | else: | ||||
| mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename | mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename | ||||
| res = '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name) | res = '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name) | ||||
| if sys.version_info.major >= 3: | if sys.version_info.major >= 3: | ||||
| res = res.encode('latin-1') | res = res.encode('latin-1') | ||||
| return res | return res | ||||
| The criteria currently is: | The criteria currently is: | ||||
| - if it's not present in _lazydirs in either t1 or t2, load it in the | - if it's not present in _lazydirs in either t1 or t2, load it in the | ||||
| other (it may already be loaded or it may not exist, doesn't matter) | other (it may already be loaded or it may not exist, doesn't matter) | ||||
| - if it's present in _lazydirs in both, compare the nodeid; if it | - if it's present in _lazydirs in both, compare the nodeid; if it | ||||
| differs, load it in both | differs, load it in both | ||||
| """ | """ | ||||
| toloadlazy = [] | toloadlazy = [] | ||||
| for d, v1 in pycompat.iteritems(t1._lazydirs): | for d, v1 in t1._lazydirs.items(): | ||||
| v2 = t2._lazydirs.get(d) | v2 = t2._lazydirs.get(d) | ||||
| if not v2 or v2[0] != v1[0]: | if not v2 or v2[0] != v1[0]: | ||||
| toloadlazy.append(d) | toloadlazy.append(d) | ||||
| for d, v1 in pycompat.iteritems(t2._lazydirs): | for d, v1 in t2._lazydirs.items(): | ||||
| if d not in t1._lazydirs: | if d not in t1._lazydirs: | ||||
| toloadlazy.append(d) | toloadlazy.append(d) | ||||
| for d in toloadlazy: | for d in toloadlazy: | ||||
| t1._loadlazy(d) | t1._loadlazy(d) | ||||
| t2._loadlazy(d) | t2._loadlazy(d) | ||||
| def __len__(self): | def __len__(self): | ||||
| self._load() | self._load() | ||||
| self._loadalllazy() | self._loadalllazy() | ||||
| for p, n in sorted( | for p, n in sorted( | ||||
| itertools.chain(self._dirs.items(), self._files.items()) | itertools.chain(self._dirs.items(), self._files.items()) | ||||
| ): | ): | ||||
| if p in self._files: | if p in self._files: | ||||
| yield self._subpath(p), n | yield self._subpath(p), n | ||||
| else: | else: | ||||
| for f, sn in pycompat.iteritems(n): | for f, sn in n.items(): | ||||
| yield f, sn | yield f, sn | ||||
| iteritems = items | iteritems = items | ||||
| def iterkeys(self): | def iterkeys(self): | ||||
| self._load() | self._load() | ||||
| self._loadalllazy() | self._loadalllazy() | ||||
| for p in sorted(itertools.chain(self._dirs, self._files)): | for p in sorted(itertools.chain(self._dirs, self._files)): | ||||
| copy = treemanifest(self.nodeconstants, self._dir) | copy = treemanifest(self.nodeconstants, self._dir) | ||||
| copy._node = self._node | copy._node = self._node | ||||
| copy._dirty = self._dirty | copy._dirty = self._dirty | ||||
| if self._copyfunc is _noop: | if self._copyfunc is _noop: | ||||
| def _copyfunc(s): | def _copyfunc(s): | ||||
| self._load() | self._load() | ||||
| s._lazydirs = { | s._lazydirs = { | ||||
| d: (n, r, True) | d: (n, r, True) for d, (n, r, c) in self._lazydirs.items() | ||||
| for d, (n, r, c) in pycompat.iteritems(self._lazydirs) | |||||
| } | } | ||||
| sdirs = s._dirs | sdirs = s._dirs | ||||
| for d, v in pycompat.iteritems(self._dirs): | for d, v in self._dirs.items(): | ||||
| sdirs[d] = v.copy() | sdirs[d] = v.copy() | ||||
| s._files = dict.copy(self._files) | s._files = dict.copy(self._files) | ||||
| s._flags = dict.copy(self._flags) | s._flags = dict.copy(self._flags) | ||||
| if self._loadfunc is _noop: | if self._loadfunc is _noop: | ||||
| _copyfunc(copy) | _copyfunc(copy) | ||||
| else: | else: | ||||
| copy._copyfunc = _copyfunc | copy._copyfunc = _copyfunc | ||||
| files = set() | files = set() | ||||
| def _filesnotin(t1, t2): | def _filesnotin(t1, t2): | ||||
| if t1._node == t2._node and not t1._dirty and not t2._dirty: | if t1._node == t2._node and not t1._dirty and not t2._dirty: | ||||
| return | return | ||||
| t1._load() | t1._load() | ||||
| t2._load() | t2._load() | ||||
| self._loaddifflazy(t1, t2) | self._loaddifflazy(t1, t2) | ||||
| for d, m1 in pycompat.iteritems(t1._dirs): | for d, m1 in t1._dirs.items(): | ||||
| if d in t2._dirs: | if d in t2._dirs: | ||||
| m2 = t2._dirs[d] | m2 = t2._dirs[d] | ||||
| _filesnotin(m1, m2) | _filesnotin(m1, m2) | ||||
| else: | else: | ||||
| files.update(m1.iterkeys()) | files.update(m1.iterkeys()) | ||||
| for fn in t1._files: | for fn in t1._files: | ||||
| if fn not in t2._files: | if fn not in t2._files: | ||||
| # matcher code to further filter results. | # matcher code to further filter results. | ||||
| if not match(fullp): | if not match(fullp): | ||||
| continue | continue | ||||
| ret._files[fn] = self._files[fn] | ret._files[fn] = self._files[fn] | ||||
| if fn in self._flags: | if fn in self._flags: | ||||
| ret._flags[fn] = self._flags[fn] | ret._flags[fn] = self._flags[fn] | ||||
| visit = self._loadchildrensetlazy(visit) | visit = self._loadchildrensetlazy(visit) | ||||
| for dir, subm in pycompat.iteritems(self._dirs): | for dir, subm in self._dirs.items(): | ||||
| if visit and dir[:-1] not in visit: | if visit and dir[:-1] not in visit: | ||||
| continue | continue | ||||
| m = subm._matches_inner(match) | m = subm._matches_inner(match) | ||||
| if not m._isempty(): | if not m._isempty(): | ||||
| ret._dirs[dir] = m | ret._dirs[dir] = m | ||||
| if not ret._isempty(): | if not ret._isempty(): | ||||
| ret._dirty = True | ret._dirty = True | ||||
| """compares two tree manifests and append new tree-manifests which | """compares two tree manifests and append new tree-manifests which | ||||
| needs to be compared to stack""" | needs to be compared to stack""" | ||||
| if t1._node == t2._node and not t1._dirty and not t2._dirty: | if t1._node == t2._node and not t1._dirty and not t2._dirty: | ||||
| return | return | ||||
| t1._load() | t1._load() | ||||
| t2._load() | t2._load() | ||||
| self._loaddifflazy(t1, t2) | self._loaddifflazy(t1, t2) | ||||
| for d, m1 in pycompat.iteritems(t1._dirs): | for d, m1 in t1._dirs.items(): | ||||
| m2 = t2._dirs.get(d, emptytree) | m2 = t2._dirs.get(d, emptytree) | ||||
| stack.append((m1, m2)) | stack.append((m1, m2)) | ||||
| for d, m2 in pycompat.iteritems(t2._dirs): | for d, m2 in t2._dirs.items(): | ||||
| if d not in t1._dirs: | if d not in t1._dirs: | ||||
| stack.append((emptytree, m2)) | stack.append((emptytree, m2)) | ||||
| for fn, n1 in pycompat.iteritems(t1._files): | for fn, n1 in t1._files.items(): | ||||
| fl1 = t1._flags.get(fn, b'') | fl1 = t1._flags.get(fn, b'') | ||||
| n2 = t2._files.get(fn, None) | n2 = t2._files.get(fn, None) | ||||
| fl2 = t2._flags.get(fn, b'') | fl2 = t2._flags.get(fn, b'') | ||||
| if n1 != n2 or fl1 != fl2: | if n1 != n2 or fl1 != fl2: | ||||
| result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2)) | result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2)) | ||||
| elif clean: | elif clean: | ||||
| result[t1._subpath(fn)] = None | result[t1._subpath(fn)] = None | ||||
| for fn, n2 in pycompat.iteritems(t2._files): | for fn, n2 in t2._files.items(): | ||||
| if fn not in t1._files: | if fn not in t1._files: | ||||
| fl2 = t2._flags.get(fn, b'') | fl2 = t2._flags.get(fn, b'') | ||||
| result[t2._subpath(fn)] = ((None, b''), (n2, fl2)) | result[t2._subpath(fn)] = ((None, b''), (n2, fl2)) | ||||
| stackls = [] | stackls = [] | ||||
| _iterativediff(self, m2, stackls) | _iterativediff(self, m2, stackls) | ||||
| while stackls: | while stackls: | ||||
| t1, t2 = stackls.pop() | t1, t2 = stackls.pop() | ||||
| return _text(self.iterentries()) | return _text(self.iterentries()) | ||||
| def dirtext(self): | def dirtext(self): | ||||
| """Get the full data of this directory as a bytestring. Make sure that | """Get the full data of this directory as a bytestring. Make sure that | ||||
| any submanifests have been written first, so their nodeids are correct. | any submanifests have been written first, so their nodeids are correct. | ||||
| """ | """ | ||||
| self._load() | self._load() | ||||
| flags = self.flags | flags = self.flags | ||||
| lazydirs = [ | lazydirs = [(d[:-1], v[0], b't') for d, v in self._lazydirs.items()] | ||||
| (d[:-1], v[0], b't') for d, v in pycompat.iteritems(self._lazydirs) | |||||
| ] | |||||
| dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs] | dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs] | ||||
| files = [(f, self._files[f], flags(f)) for f in self._files] | files = [(f, self._files[f], flags(f)) for f in self._files] | ||||
| return _text(sorted(dirs + files + lazydirs)) | return _text(sorted(dirs + files + lazydirs)) | ||||
| def read(self, gettext, readsubtree): | def read(self, gettext, readsubtree): | ||||
| def _load_for_read(s): | def _load_for_read(s): | ||||
| s.parse(gettext(), readsubtree) | s.parse(gettext(), readsubtree) | ||||
| s._dirty = False | s._dirty = False | ||||
| return ld[0] | return ld[0] | ||||
| return m._dirs.get(d, emptytree)._node | return m._dirs.get(d, emptytree)._node | ||||
| # let's skip investigating things that `match` says we do not need. | # let's skip investigating things that `match` says we do not need. | ||||
| visit = match.visitchildrenset(self._dir[:-1]) | visit = match.visitchildrenset(self._dir[:-1]) | ||||
| visit = self._loadchildrensetlazy(visit) | visit = self._loadchildrensetlazy(visit) | ||||
| if visit == b'this' or visit == b'all': | if visit == b'this' or visit == b'all': | ||||
| visit = None | visit = None | ||||
| for d, subm in pycompat.iteritems(self._dirs): | for d, subm in self._dirs.items(): | ||||
| if visit and d[:-1] not in visit: | if visit and d[:-1] not in visit: | ||||
| continue | continue | ||||
| subp1 = getnode(m1, d) | subp1 = getnode(m1, d) | ||||
| subp2 = getnode(m2, d) | subp2 = getnode(m2, d) | ||||
| if subp1 == self.nodeconstants.nullid: | if subp1 == self.nodeconstants.nullid: | ||||
| subp1, subp2 = subp2, subp1 | subp1, subp2 = subp2, subp1 | ||||
| writesubtree(subm, subp1, subp2, match) | writesubtree(subm, subp1, subp2, match) | ||||
| def walksubtrees(self, matcher=None): | def walksubtrees(self, matcher=None): | ||||
| """Returns an iterator of the subtrees of this manifest, including this | """Returns an iterator of the subtrees of this manifest, including this | ||||
| manifest itself. | manifest itself. | ||||
| If `matcher` is provided, it only returns subtrees that match. | If `matcher` is provided, it only returns subtrees that match. | ||||
| """ | """ | ||||
| if matcher and not matcher.visitdir(self._dir[:-1]): | if matcher and not matcher.visitdir(self._dir[:-1]): | ||||
| return | return | ||||
| if not matcher or matcher(self._dir[:-1]): | if not matcher or matcher(self._dir[:-1]): | ||||
| yield self | yield self | ||||
| self._load() | self._load() | ||||
| # OPT: use visitchildrenset to avoid loading everything. | # OPT: use visitchildrenset to avoid loading everything. | ||||
| self._loadalllazy() | self._loadalllazy() | ||||
| for d, subm in pycompat.iteritems(self._dirs): | for d, subm in self._dirs.items(): | ||||
| for subtree in subm.walksubtrees(matcher=matcher): | for subtree in subm.walksubtrees(matcher=matcher): | ||||
| yield subtree | yield subtree | ||||
| class manifestfulltextcache(util.lrucachedict): | class manifestfulltextcache(util.lrucachedict): | ||||
| """File-backed LRU cache for the manifest cache | """File-backed LRU cache for the manifest cache | ||||
| File consists of entries, up to EOF: | File consists of entries, up to EOF: | ||||
| except KeyError: | except KeyError: | ||||
| if warn: | if warn: | ||||
| warn( | warn( | ||||
| _(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s) | _(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s) | ||||
| ) | ) | ||||
| continue | continue | ||||
| linesyntax = syntax | linesyntax = syntax | ||||
| for s, rels in pycompat.iteritems(syntaxes): | for s, rels in syntaxes.items(): | ||||
| if line.startswith(rels): | if line.startswith(rels): | ||||
| linesyntax = rels | linesyntax = rels | ||||
| line = line[len(rels) :] | line = line[len(rels) :] | ||||
| break | break | ||||
| elif line.startswith(s + b':'): | elif line.startswith(s + b':'): | ||||
| linesyntax = rels | linesyntax = rels | ||||
| line = line[len(s) + 1 :] | line = line[len(s) + 1 :] | ||||
| break | break | ||||
| if sourceinfo: | if sourceinfo: | ||||
| patterns.append((linesyntax + line, lineno, line)) | patterns.append((linesyntax + line, lineno, line)) | ||||
| else: | else: | ||||
| patterns.append(linesyntax + line) | patterns.append(linesyntax + line) | ||||
| fp.close() | fp.close() | ||||
| return patterns | return patterns | ||||
| if actions is None: | if actions is None: | ||||
| return len(self._filemapping) | return len(self._filemapping) | ||||
| return sum(len(self._actionmapping[a]) for a in actions) | return sum(len(self._actionmapping[a]) for a in actions) | ||||
| def filemap(self, sort=False): | def filemap(self, sort=False): | ||||
| if sorted: | if sorted: | ||||
| for key, val in sorted(pycompat.iteritems(self._filemapping)): | for key, val in sorted(self._filemapping.items()): | ||||
| yield key, val | yield key, val | ||||
| else: | else: | ||||
| for key, val in pycompat.iteritems(self._filemapping): | for key, val in self._filemapping.items(): | ||||
| yield key, val | yield key, val | ||||
| def addcommitinfo(self, filename, key, value): | def addcommitinfo(self, filename, key, value): | ||||
| """adds key-value information about filename which will be required | """adds key-value information about filename which will be required | ||||
| while committing this merge""" | while committing this merge""" | ||||
| self._commitinfo[filename][key] = value | self._commitinfo[filename][key] = value | ||||
| @property | @property | ||||
| def diverge(self): | def diverge(self): | ||||
| return self._diverge | return self._diverge | ||||
| @property | @property | ||||
| def renamedelete(self): | def renamedelete(self): | ||||
| return self._renamedelete | return self._renamedelete | ||||
| @property | @property | ||||
| def commitinfo(self): | def commitinfo(self): | ||||
| return self._commitinfo | return self._commitinfo | ||||
| @property | @property | ||||
| def actionsdict(self): | def actionsdict(self): | ||||
| """returns a dictionary of actions to be perfomed with action as key | """returns a dictionary of actions to be perfomed with action as key | ||||
| and a list of files and related arguments as values""" | and a list of files and related arguments as values""" | ||||
| res = collections.defaultdict(list) | res = collections.defaultdict(list) | ||||
| for a, d in pycompat.iteritems(self._actionmapping): | for a, d in self._actionmapping.items(): | ||||
| for f, (args, msg) in pycompat.iteritems(d): | for f, (args, msg) in d.items(): | ||||
| res[a].append((f, args, msg)) | res[a].append((f, args, msg)) | ||||
| return res | return res | ||||
| def setactions(self, actions): | def setactions(self, actions): | ||||
| self._filemapping = actions | self._filemapping = actions | ||||
| self._actionmapping = collections.defaultdict(dict) | self._actionmapping = collections.defaultdict(dict) | ||||
| for f, (act, data, msg) in pycompat.iteritems(self._filemapping): | for f, (act, data, msg) in self._filemapping.items(): | ||||
| self._actionmapping[act][f] = data, msg | self._actionmapping[act][f] = data, msg | ||||
| def hasconflicts(self): | def hasconflicts(self): | ||||
| """tells whether this merge resulted in some actions which can | """tells whether this merge resulted in some actions which can | ||||
| result in conflicts or not""" | result in conflicts or not""" | ||||
| for a in self._actionmapping.keys(): | for a in self._actionmapping.keys(): | ||||
| if ( | if ( | ||||
| a | a | ||||
| ) | ) | ||||
| ): | ): | ||||
| # Identify which files are relevant to the merge, so we can limit the | # Identify which files are relevant to the merge, so we can limit the | ||||
| # total m1-vs-m2 diff to just those files. This has significant | # total m1-vs-m2 diff to just those files. This has significant | ||||
| # performance benefits in large repositories. | # performance benefits in large repositories. | ||||
| relevantfiles = set(ma.diff(m2).keys()) | relevantfiles = set(ma.diff(m2).keys()) | ||||
| # For copied and moved files, we need to add the source file too. | # For copied and moved files, we need to add the source file too. | ||||
| for copykey, copyvalue in pycompat.iteritems(branch_copies1.copy): | for copykey, copyvalue in branch_copies1.copy.items(): | ||||
| if copyvalue in relevantfiles: | if copyvalue in relevantfiles: | ||||
| relevantfiles.add(copykey) | relevantfiles.add(copykey) | ||||
| for movedirkey in branch_copies1.movewithdir: | for movedirkey in branch_copies1.movewithdir: | ||||
| relevantfiles.add(movedirkey) | relevantfiles.add(movedirkey) | ||||
| filesmatcher = scmutil.matchfiles(repo, relevantfiles) | filesmatcher = scmutil.matchfiles(repo, relevantfiles) | ||||
| matcher = matchmod.intersectmatchers(matcher, filesmatcher) | matcher = matchmod.intersectmatchers(matcher, filesmatcher) | ||||
| diff = m1.diff(m2, match=matcher) | diff = m1.diff(m2, match=matcher) | ||||
| for f, ((n1, fl1), (n2, fl2)) in pycompat.iteritems(diff): | for f, ((n1, fl1), (n2, fl2)) in diff.items(): | ||||
| if n1 and n2: # file exists on both local and remote side | if n1 and n2: # file exists on both local and remote side | ||||
| if f not in ma: | if f not in ma: | ||||
| # TODO: what if they're renamed from different sources? | # TODO: what if they're renamed from different sources? | ||||
| fa = branch_copies1.copy.get( | fa = branch_copies1.copy.get( | ||||
| f, None | f, None | ||||
| ) or branch_copies2.copy.get(f, None) | ) or branch_copies2.copy.get(f, None) | ||||
| args, msg = None, None | args, msg = None, None | ||||
| if fa is not None: | if fa is not None: | ||||
| """ | """ | ||||
| _prefetchfiles(repo, mctx, mresult) | _prefetchfiles(repo, mctx, mresult) | ||||
| updated, merged, removed = 0, 0, 0 | updated, merged, removed = 0, 0, 0 | ||||
| ms = wctx.mergestate(clean=True) | ms = wctx.mergestate(clean=True) | ||||
| ms.start(wctx.p1().node(), mctx.node(), labels) | ms.start(wctx.p1().node(), mctx.node(), labels) | ||||
| for f, op in pycompat.iteritems(mresult.commitinfo): | for f, op in mresult.commitinfo.items(): | ||||
| # the other side of filenode was choosen while merging, store this in | # the other side of filenode was choosen while merging, store this in | ||||
| # mergestate so that it can be reused on commit | # mergestate so that it can be reused on commit | ||||
| ms.addcommitinfo(f, op) | ms.addcommitinfo(f, op) | ||||
| num_no_op = mresult.len(mergestatemod.MergeAction.NO_OP_ACTIONS) | num_no_op = mresult.len(mergestatemod.MergeAction.NO_OP_ACTIONS) | ||||
| numupdates = mresult.len() - num_no_op | numupdates = mresult.len() - num_no_op | ||||
| progress = repo.ui.makeprogress( | progress = repo.ui.makeprogress( | ||||
| _(b'updating'), unit=_(b'files'), total=numupdates | _(b'updating'), unit=_(b'files'), total=numupdates | ||||
| if not branchmerge and ( | if not branchmerge and ( | ||||
| force or not wc.dirty(missing=True, branch=False) | force or not wc.dirty(missing=True, branch=False) | ||||
| ): | ): | ||||
| _checkcollision(repo, p2.manifest(), None) | _checkcollision(repo, p2.manifest(), None) | ||||
| else: | else: | ||||
| _checkcollision(repo, wc.manifest(), mresult) | _checkcollision(repo, wc.manifest(), mresult) | ||||
| # divergent renames | # divergent renames | ||||
| for f, fl in sorted(pycompat.iteritems(mresult.diverge)): | for f, fl in sorted(mresult.diverge.items()): | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _( | _( | ||||
| b"note: possible conflict - %s was renamed " | b"note: possible conflict - %s was renamed " | ||||
| b"multiple times to:\n" | b"multiple times to:\n" | ||||
| ) | ) | ||||
| % f | % f | ||||
| ) | ) | ||||
| for nf in sorted(fl): | for nf in sorted(fl): | ||||
| repo.ui.warn(b" %s\n" % nf) | repo.ui.warn(b" %s\n" % nf) | ||||
| # rename and delete | # rename and delete | ||||
| for f, fl in sorted(pycompat.iteritems(mresult.renamedelete)): | for f, fl in sorted(mresult.renamedelete.items()): | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _( | _( | ||||
| b"note: possible conflict - %s was deleted " | b"note: possible conflict - %s was deleted " | ||||
| b"and renamed to:\n" | b"and renamed to:\n" | ||||
| ) | ) | ||||
| % f | % f | ||||
| ) | ) | ||||
| for nf in sorted(fl): | for nf in sorted(fl): | ||||
| p2, | p2, | ||||
| overwrite, | overwrite, | ||||
| wantfiledata, | wantfiledata, | ||||
| labels=labels, | labels=labels, | ||||
| ) | ) | ||||
| if updatedirstate: | if updatedirstate: | ||||
| if extraactions: | if extraactions: | ||||
| for k, acts in pycompat.iteritems(extraactions): | for k, acts in extraactions.items(): | ||||
| for a in acts: | for a in acts: | ||||
| mresult.addfile(a[0], k, *a[1:]) | mresult.addfile(a[0], k, *a[1:]) | ||||
| if k == mergestatemod.ACTION_GET and wantfiledata: | if k == mergestatemod.ACTION_GET and wantfiledata: | ||||
| # no filedata until mergestate is updated to provide it | # no filedata until mergestate is updated to provide it | ||||
| for a in acts: | for a in acts: | ||||
| getfiledata[a[0]] = None | getfiledata[a[0]] = None | ||||
| assert len(getfiledata) == ( | assert len(getfiledata) == ( | ||||
| now = timestamp.get_fs_now(repo.vfs) | now = timestamp.get_fs_now(repo.vfs) | ||||
| if now is None: | if now is None: | ||||
| # we can't write to the FS, so we won't actually update | # we can't write to the FS, so we won't actually update | ||||
| # the dirstate content anyway, no need to put cache | # the dirstate content anyway, no need to put cache | ||||
| # information. | # information. | ||||
| getfiledata = None | getfiledata = None | ||||
| else: | else: | ||||
| now_sec = now[0] | now_sec = now[0] | ||||
| for f, m in pycompat.iteritems(getfiledata): | for f, m in getfiledata.items(): | ||||
| if m is not None and m[2][0] >= now_sec: | if m is not None and m[2][0] >= now_sec: | ||||
| ambiguous_mtime[f] = (m[0], m[1], None) | ambiguous_mtime[f] = (m[0], m[1], None) | ||||
| for f, m in pycompat.iteritems(ambiguous_mtime): | for f, m in ambiguous_mtime.items(): | ||||
| getfiledata[f] = m | getfiledata[f] = m | ||||
| repo.setparents(fp1, fp2) | repo.setparents(fp1, fp2) | ||||
| mergestatemod.recordupdates( | mergestatemod.recordupdates( | ||||
| repo, mresult.actionsdict, branchmerge, getfiledata | repo, mresult.actionsdict, branchmerge, getfiledata | ||||
| ) | ) | ||||
| # update completed, clear state | # update completed, clear state | ||||
| util.unlink(repo.vfs.join(b'updatestate')) | util.unlink(repo.vfs.join(b'updatestate')) | ||||
| def mark(self, dfile, state): | def mark(self, dfile, state): | ||||
| self._state[dfile][0] = state | self._state[dfile][0] = state | ||||
| self._dirty = True | self._dirty = True | ||||
| def unresolved(self): | def unresolved(self): | ||||
| """Obtain the paths of unresolved files.""" | """Obtain the paths of unresolved files.""" | ||||
| for f, entry in pycompat.iteritems(self._state): | for f, entry in self._state.items(): | ||||
| if entry[0] in ( | if entry[0] in ( | ||||
| MERGE_RECORD_UNRESOLVED, | MERGE_RECORD_UNRESOLVED, | ||||
| MERGE_RECORD_UNRESOLVED_PATH, | MERGE_RECORD_UNRESOLVED_PATH, | ||||
| ): | ): | ||||
| yield f | yield f | ||||
| def allextras(self): | def allextras(self): | ||||
| """return all extras information stored with the mergestate""" | """return all extras information stored with the mergestate""" | ||||
| """return lists of actions to perform on the dirstate""" | """return lists of actions to perform on the dirstate""" | ||||
| actions = { | actions = { | ||||
| ACTION_REMOVE: [], | ACTION_REMOVE: [], | ||||
| ACTION_FORGET: [], | ACTION_FORGET: [], | ||||
| ACTION_ADD: [], | ACTION_ADD: [], | ||||
| ACTION_ADD_MODIFIED: [], | ACTION_ADD_MODIFIED: [], | ||||
| ACTION_GET: [], | ACTION_GET: [], | ||||
| } | } | ||||
| for f, (r, action) in pycompat.iteritems(self._results): | for f, (r, action) in self._results.items(): | ||||
| if action is not None: | if action is not None: | ||||
| actions[action].append((f, None, b"merge result")) | actions[action].append((f, None, b"merge result")) | ||||
| return actions | return actions | ||||
| class mergestate(_mergestate_base): | class mergestate(_mergestate_base): | ||||
| statepathv1 = b'merge/state' | statepathv1 = b'merge/state' | ||||
| records = [] | records = [] | ||||
| records.append((RECORD_LOCAL, hex(self._local))) | records.append((RECORD_LOCAL, hex(self._local))) | ||||
| records.append((RECORD_OTHER, hex(self._other))) | records.append((RECORD_OTHER, hex(self._other))) | ||||
| # Write out state items. In all cases, the value of the state map entry | # Write out state items. In all cases, the value of the state map entry | ||||
| # is written as the contents of the record. The record type depends on | # is written as the contents of the record. The record type depends on | ||||
| # the type of state that is stored, and capital-letter records are used | # the type of state that is stored, and capital-letter records are used | ||||
| # to prevent older versions of Mercurial that do not support the feature | # to prevent older versions of Mercurial that do not support the feature | ||||
| # from loading them. | # from loading them. | ||||
| for filename, v in pycompat.iteritems(self._state): | for filename, v in self._state.items(): | ||||
| if v[0] in ( | if v[0] in ( | ||||
| MERGE_RECORD_UNRESOLVED_PATH, | MERGE_RECORD_UNRESOLVED_PATH, | ||||
| MERGE_RECORD_RESOLVED_PATH, | MERGE_RECORD_RESOLVED_PATH, | ||||
| ): | ): | ||||
| # Path conflicts. These are stored in 'P' records. The current | # Path conflicts. These are stored in 'P' records. The current | ||||
| # resolution state ('pu' or 'pr') is stored within the record. | # resolution state ('pu' or 'pr') is stored within the record. | ||||
| records.append( | records.append( | ||||
| (RECORD_PATH_CONFLICT, b'\0'.join([filename] + v)) | (RECORD_PATH_CONFLICT, b'\0'.join([filename] + v)) | ||||
| ) | ) | ||||
| elif ( | elif ( | ||||
| v[1] == self._repo.nodeconstants.nullhex | v[1] == self._repo.nodeconstants.nullhex | ||||
| or v[6] == self._repo.nodeconstants.nullhex | or v[6] == self._repo.nodeconstants.nullhex | ||||
| ): | ): | ||||
| # Change/Delete or Delete/Change conflicts. These are stored in | # Change/Delete or Delete/Change conflicts. These are stored in | ||||
| # 'C' records. v[1] is the local file, and is nullhex when the | # 'C' records. v[1] is the local file, and is nullhex when the | ||||
| # file is deleted locally ('dc'). v[6] is the remote file, and | # file is deleted locally ('dc'). v[6] is the remote file, and | ||||
| # is nullhex when the file is deleted remotely ('cd'). | # is nullhex when the file is deleted remotely ('cd'). | ||||
| records.append( | records.append( | ||||
| (RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v)) | (RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v)) | ||||
| ) | ) | ||||
| else: | else: | ||||
| # Normal files. These are stored in 'F' records. | # Normal files. These are stored in 'F' records. | ||||
| records.append((RECORD_MERGED, b'\0'.join([filename] + v))) | records.append((RECORD_MERGED, b'\0'.join([filename] + v))) | ||||
| for filename, extras in sorted(pycompat.iteritems(self._stateextras)): | for filename, extras in sorted(self._stateextras.items()): | ||||
| rawextras = b'\0'.join( | rawextras = b'\0'.join( | ||||
| b'%s\0%s' % (k, v) for k, v in pycompat.iteritems(extras) | b'%s\0%s' % (k, v) for k, v in extras.items() | ||||
| ) | ) | ||||
| records.append( | records.append( | ||||
| (RECORD_FILE_VALUES, b'%s\0%s' % (filename, rawextras)) | (RECORD_FILE_VALUES, b'%s\0%s' % (filename, rawextras)) | ||||
| ) | ) | ||||
| if self._labels is not None: | if self._labels is not None: | ||||
| labels = b'\0'.join(self._labels) | labels = b'\0'.join(self._labels) | ||||
| records.append((RECORD_LABELS, labels)) | records.append((RECORD_LABELS, labels)) | ||||
| return records | return records | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from . import ( | from . import ( | ||||
| pycompat, | |||||
| registrar, | registrar, | ||||
| templatekw, | templatekw, | ||||
| util, | util, | ||||
| ) | ) | ||||
| def tolist(val): | def tolist(val): | ||||
| """ | """ | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return self._names.__iter__() | return self._names.__iter__() | ||||
| def get(self, namespace, default=None): | def get(self, namespace, default=None): | ||||
| return self._names.get(namespace, default) | return self._names.get(namespace, default) | ||||
| def items(self): | def items(self): | ||||
| return pycompat.iteritems(self._names) | return self._names.items() | ||||
| iteritems = items | iteritems = items | ||||
| def addnamespace(self, namespace, order=None): | def addnamespace(self, namespace, order=None): | ||||
| """register a namespace | """register a namespace | ||||
| namespace: the name to be registered (in plural form) | namespace: the name to be registered (in plural form) | ||||
| order: optional argument to specify the order of namespaces | order: optional argument to specify the order of namespaces | ||||
| def singlenode(self, repo, name): | def singlenode(self, repo, name): | ||||
| """ | """ | ||||
| Return the 'best' node for the given name. What's best is defined | Return the 'best' node for the given name. What's best is defined | ||||
| by the namespace's singlenode() function. The first match returned by | by the namespace's singlenode() function. The first match returned by | ||||
| a namespace in the defined precedence order is used. | a namespace in the defined precedence order is used. | ||||
| Raises a KeyError if there is no such node. | Raises a KeyError if there is no such node. | ||||
| """ | """ | ||||
| for ns, v in pycompat.iteritems(self._names): | for ns, v in self._names.items(): | ||||
| n = v.singlenode(repo, name) | n = v.singlenode(repo, name) | ||||
| if n: | if n: | ||||
| return n | return n | ||||
| raise KeyError(_(b'no such name: %s') % name) | raise KeyError(_(b'no such name: %s') % name) | ||||
| class namespace(object): | class namespace(object): | ||||
| """provides an interface to a namespace | """provides an interface to a namespace | ||||
| for p in parents: | for p in parents: | ||||
| if len(p) != 20: | if len(p) != 20: | ||||
| parents = None | parents = None | ||||
| break | break | ||||
| except TypeError: | except TypeError: | ||||
| # if content cannot be translated to nodeid drop the data. | # if content cannot be translated to nodeid drop the data. | ||||
| parents = None | parents = None | ||||
| metadata = tuple(sorted(pycompat.iteritems(metadata))) | metadata = tuple(sorted(metadata.items())) | ||||
| yield (pre, sucs, flags, metadata, date, parents) | yield (pre, sucs, flags, metadata, date, parents) | ||||
| def _fm0encodeonemarker(marker): | def _fm0encodeonemarker(marker): | ||||
| pre, sucs, flags, metadata, date, parents = marker | pre, sucs, flags, metadata, date, parents = marker | ||||
| if flags & usingsha256: | if flags & usingsha256: | ||||
| raise error.Abort(_(b'cannot handle sha256 with old obsstore format')) | raise error.Abort(_(b'cannot handle sha256 with old obsstore format')) | ||||
| data.extend(sucs) | data.extend(sucs) | ||||
| return _pack(format, *data) + metadata | return _pack(format, *data) + metadata | ||||
| def _fm0encodemeta(meta): | def _fm0encodemeta(meta): | ||||
| """Return encoded metadata string to string mapping. | """Return encoded metadata string to string mapping. | ||||
| Assume no ':' in key and no '\0' in both key and value.""" | Assume no ':' in key and no '\0' in both key and value.""" | ||||
| for key, value in pycompat.iteritems(meta): | for key, value in meta.items(): | ||||
| if b':' in key or b'\0' in key: | if b':' in key or b'\0' in key: | ||||
| raise ValueError(b"':' and '\0' are forbidden in metadata key'") | raise ValueError(b"':' and '\0' are forbidden in metadata key'") | ||||
| if b'\0' in value: | if b'\0' in value: | ||||
| raise ValueError(b"':' is forbidden in metadata value'") | raise ValueError(b"':' is forbidden in metadata value'") | ||||
| return b'\0'.join([b'%s:%s' % (k, meta[k]) for k in sorted(meta)]) | return b'\0'.join([b'%s:%s' % (k, meta[k]) for k in sorted(meta)]) | ||||
| def _fm0decodemeta(data): | def _fm0decodemeta(data): | ||||
| for succ in succs: | for succ in succs: | ||||
| if len(succ) != 20: | if len(succ) != 20: | ||||
| raise ValueError(succ) | raise ValueError(succ) | ||||
| if prec in succs: | if prec in succs: | ||||
| raise ValueError( | raise ValueError( | ||||
| 'in-marker cycle with %s' % pycompat.sysstr(hex(prec)) | 'in-marker cycle with %s' % pycompat.sysstr(hex(prec)) | ||||
| ) | ) | ||||
| metadata = tuple(sorted(pycompat.iteritems(metadata))) | metadata = tuple(sorted(metadata.items())) | ||||
| for k, v in metadata: | for k, v in metadata: | ||||
| try: | try: | ||||
| # might be better to reject non-ASCII keys | # might be better to reject non-ASCII keys | ||||
| k.decode('utf-8') | k.decode('utf-8') | ||||
| v.decode('utf-8') | v.decode('utf-8') | ||||
| except UnicodeDecodeError: | except UnicodeDecodeError: | ||||
| raise error.ProgrammingError( | raise error.ProgrammingError( | ||||
| b'obsstore metadata must be valid UTF-8 sequence ' | b'obsstore metadata must be valid UTF-8 sequence ' | ||||
| hex, | hex, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| diffutil, | diffutil, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| phases, | phases, | ||||
| pycompat, | |||||
| util, | util, | ||||
| ) | ) | ||||
| from .utils import dateutil | from .utils import dateutil | ||||
| ### obsolescence marker flag | ### obsolescence marker flag | ||||
| ## bumpedfix flag | ## bumpedfix flag | ||||
| # | # | ||||
| # we are only interested in *other* successor sets | # we are only interested in *other* successor sets | ||||
| continue | continue | ||||
| if tuple(nsuccset) in base: | if tuple(nsuccset) in base: | ||||
| # we already know the latest base for this divergency | # we already know the latest base for this divergency | ||||
| continue | continue | ||||
| base[tuple(nsuccset)] = n | base[tuple(nsuccset)] = n | ||||
| return [ | return [ | ||||
| {b'divergentnodes': divset, b'commonpredecessor': b} | {b'divergentnodes': divset, b'commonpredecessor': b} | ||||
| for divset, b in pycompat.iteritems(base) | for divset, b in base.items() | ||||
| ] | ] | ||||
| def whyunstable(repo, ctx): | def whyunstable(repo, ctx): | ||||
| result = [] | result = [] | ||||
| if ctx.orphan(): | if ctx.orphan(): | ||||
| for parent in ctx.parents(): | for parent in ctx.parents(): | ||||
| kind = None | kind = None | ||||
| if copy is None: | if copy is None: | ||||
| copy = {} | copy = {} | ||||
| if opts.git or opts.upgrade: | if opts.git or opts.upgrade: | ||||
| copy = copies.pathcopies(ctx1, ctx2, match=match) | copy = copies.pathcopies(ctx1, ctx2, match=match) | ||||
| if copysourcematch: | if copysourcematch: | ||||
| # filter out copies where source side isn't inside the matcher | # filter out copies where source side isn't inside the matcher | ||||
| # (copies.pathcopies() already filtered out the destination) | # (copies.pathcopies() already filtered out the destination) | ||||
| copy = { | copy = {dst: src for dst, src in copy.items() if copysourcematch(src)} | ||||
| dst: src | |||||
| for dst, src in pycompat.iteritems(copy) | |||||
| if copysourcematch(src) | |||||
| } | |||||
| modifiedset = set(modified) | modifiedset = set(modified) | ||||
| addedset = set(added) | addedset = set(added) | ||||
| removedset = set(removed) | removedset = set(removed) | ||||
| for f in modified: | for f in modified: | ||||
| if f not in ctx1: | if f not in ctx1: | ||||
| # Fix up added, since merged-in additions appear as | # Fix up added, since merged-in additions appear as | ||||
| # modifications during merges | # modifications during merges | ||||
| def __init__(self, map, only_tracked=False): | def __init__(self, map, only_tracked=False): | ||||
| """ | """ | ||||
| a dict map indicates a dirstate while a list indicates a manifest | a dict map indicates a dirstate while a list indicates a manifest | ||||
| """ | """ | ||||
| self._dirs = {} | self._dirs = {} | ||||
| addpath = self.addpath | addpath = self.addpath | ||||
| if isinstance(map, dict) and only_tracked: | if isinstance(map, dict) and only_tracked: | ||||
| for f, s in pycompat.iteritems(map): | for f, s in map.items(): | ||||
| if s.state != b'r': | if s.state != b'r': | ||||
| addpath(f) | addpath(f) | ||||
| elif only_tracked: | elif only_tracked: | ||||
| msg = b"`only_tracked` is only supported with a dict source" | msg = b"`only_tracked` is only supported with a dict source" | ||||
| raise error.ProgrammingError(msg) | raise error.ProgrammingError(msg) | ||||
| else: | else: | ||||
| for f in map: | for f in map: | ||||
| addpath(f) | addpath(f) | ||||
| def binaryencode(phasemapping): | def binaryencode(phasemapping): | ||||
| # type: (Dict[int, List[bytes]]) -> bytes | # type: (Dict[int, List[bytes]]) -> bytes | ||||
| """encode a 'phase -> nodes' mapping into a binary stream | """encode a 'phase -> nodes' mapping into a binary stream | ||||
| The revision lists are encoded as (phase, root) pairs. | The revision lists are encoded as (phase, root) pairs. | ||||
| """ | """ | ||||
| binarydata = [] | binarydata = [] | ||||
| for phase, nodes in pycompat.iteritems(phasemapping): | for phase, nodes in phasemapping.items(): | ||||
| for head in nodes: | for head in nodes: | ||||
| binarydata.append(_fphasesentry.pack(phase, head)) | binarydata.append(_fphasesentry.pack(phase, head)) | ||||
| return b''.join(binarydata) | return b''.join(binarydata) | ||||
| def binarydecode(stream): | def binarydecode(stream): | ||||
| # type: (...) -> Dict[int, List[bytes]] | # type: (...) -> Dict[int, List[bytes]] | ||||
| """decode a binary stream into a 'phase -> nodes' mapping | """decode a binary stream into a 'phase -> nodes' mapping | ||||
| # type: (localrepo.localrepository) -> bool | # type: (localrepo.localrepository) -> bool | ||||
| """detect if there are revisions with non-public phase""" | """detect if there are revisions with non-public phase""" | ||||
| repo = repo.unfiltered() | repo = repo.unfiltered() | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| if len(cl) >= self._loadedrevslen: | if len(cl) >= self._loadedrevslen: | ||||
| self.invalidate() | self.invalidate() | ||||
| self.loadphaserevs(repo) | self.loadphaserevs(repo) | ||||
| return any( | return any( | ||||
| revs | revs for phase, revs in self.phaseroots.items() if phase != public | ||||
| for phase, revs in pycompat.iteritems(self.phaseroots) | |||||
| if phase != public | |||||
| ) | ) | ||||
| def nonpublicphaseroots(self, repo): | def nonpublicphaseroots(self, repo): | ||||
| # type: (localrepo.localrepository) -> Set[bytes] | # type: (localrepo.localrepository) -> Set[bytes] | ||||
| """returns the roots of all non-public phases | """returns the roots of all non-public phases | ||||
| The roots are not minimized, so if the secret revisions are | The roots are not minimized, so if the secret revisions are | ||||
| descendants of draft revisions, their roots will still be present. | descendants of draft revisions, their roots will still be present. | ||||
| """ | """ | ||||
| repo = repo.unfiltered() | repo = repo.unfiltered() | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| if len(cl) >= self._loadedrevslen: | if len(cl) >= self._loadedrevslen: | ||||
| self.invalidate() | self.invalidate() | ||||
| self.loadphaserevs(repo) | self.loadphaserevs(repo) | ||||
| return set().union( | return set().union( | ||||
| *[ | *[ | ||||
| revs | revs | ||||
| for phase, revs in pycompat.iteritems(self.phaseroots) | for phase, revs in self.phaseroots.items() | ||||
| if phase != public | if phase != public | ||||
| ] | ] | ||||
| ) | ) | ||||
| def getrevset(self, repo, phases, subset=None): | def getrevset(self, repo, phases, subset=None): | ||||
| # type: (localrepo.localrepository, Iterable[int], Optional[Any]) -> Any | # type: (localrepo.localrepository, Iterable[int], Optional[Any]) -> Any | ||||
| # TODO: finish typing this | # TODO: finish typing this | ||||
| """return a smartset for the given phases""" | """return a smartset for the given phases""" | ||||
| return | return | ||||
| f = self.opener(b'phaseroots', b'w', atomictemp=True, checkambig=True) | f = self.opener(b'phaseroots', b'w', atomictemp=True, checkambig=True) | ||||
| try: | try: | ||||
| self._write(f) | self._write(f) | ||||
| finally: | finally: | ||||
| f.close() | f.close() | ||||
| def _write(self, fp): | def _write(self, fp): | ||||
| for phase, roots in pycompat.iteritems(self.phaseroots): | for phase, roots in self.phaseroots.items(): | ||||
| for h in sorted(roots): | for h in sorted(roots): | ||||
| fp.write(b'%i %s\n' % (phase, hex(h))) | fp.write(b'%i %s\n' % (phase, hex(h))) | ||||
| self.dirty = False | self.dirty = False | ||||
| def _updateroots(self, phase, newroots, tr): | def _updateroots(self, phase, newroots, tr): | ||||
| self.phaseroots[phase] = newroots | self.phaseroots[phase] = newroots | ||||
| self.invalidate() | self.invalidate() | ||||
| self.dirty = True | self.dirty = True | ||||
| if targetphase != 0: | if targetphase != 0: | ||||
| self._retractboundary(repo, tr, targetphase, delroots) | self._retractboundary(repo, tr, targetphase, delroots) | ||||
| repo.invalidatevolatilesets() | repo.invalidatevolatilesets() | ||||
| return changes | return changes | ||||
| def retractboundary(self, repo, tr, targetphase, nodes): | def retractboundary(self, repo, tr, targetphase, nodes): | ||||
| oldroots = { | oldroots = { | ||||
| phase: revs | phase: revs | ||||
| for phase, revs in pycompat.iteritems(self.phaseroots) | for phase, revs in self.phaseroots.items() | ||||
| if phase <= targetphase | if phase <= targetphase | ||||
| } | } | ||||
| if tr is None: | if tr is None: | ||||
| phasetracking = None | phasetracking = None | ||||
| else: | else: | ||||
| phasetracking = tr.changes.get(b'phases') | phasetracking = tr.changes.get(b'phases') | ||||
| repo = repo.unfiltered() | repo = repo.unfiltered() | ||||
| if ( | if ( | ||||
| def filterunknown(self, repo): | def filterunknown(self, repo): | ||||
| # type: (localrepo.localrepository) -> None | # type: (localrepo.localrepository) -> None | ||||
| """remove unknown nodes from the phase boundary | """remove unknown nodes from the phase boundary | ||||
| Nothing is lost as unknown nodes only hold data for their descendants. | Nothing is lost as unknown nodes only hold data for their descendants. | ||||
| """ | """ | ||||
| filtered = False | filtered = False | ||||
| has_node = repo.changelog.index.has_node # to filter unknown nodes | has_node = repo.changelog.index.has_node # to filter unknown nodes | ||||
| for phase, nodes in pycompat.iteritems(self.phaseroots): | for phase, nodes in self.phaseroots.items(): | ||||
| missing = sorted(node for node in nodes if not has_node(node)) | missing = sorted(node for node in nodes if not has_node(node)) | ||||
| if missing: | if missing: | ||||
| for mnode in missing: | for mnode in missing: | ||||
| repo.ui.debug( | repo.ui.debug( | ||||
| b'removing unknown node %s from %i-phase boundary\n' | b'removing unknown node %s from %i-phase boundary\n' | ||||
| % (short(mnode), phase) | % (short(mnode), phase) | ||||
| ) | ) | ||||
| nodes.symmetric_difference_update(missing) | nodes.symmetric_difference_update(missing) | ||||
| * roots is {<nodeid> => phase} mapping. key and value are string. | * roots is {<nodeid> => phase} mapping. key and value are string. | ||||
| Accept unknown element input | Accept unknown element input | ||||
| """ | """ | ||||
| repo = repo.unfiltered() | repo = repo.unfiltered() | ||||
| # build list from dictionary | # build list from dictionary | ||||
| draftroots = [] | draftroots = [] | ||||
| has_node = repo.changelog.index.has_node # to filter unknown nodes | has_node = repo.changelog.index.has_node # to filter unknown nodes | ||||
| for nhex, phase in pycompat.iteritems(roots): | for nhex, phase in roots.items(): | ||||
| if nhex == b'publishing': # ignore data related to publish option | if nhex == b'publishing': # ignore data related to publish option | ||||
| continue | continue | ||||
| node = bin(nhex) | node = bin(nhex) | ||||
| phase = int(phase) | phase = int(phase) | ||||
| if phase == public: | if phase == public: | ||||
| if node != repo.nullid: | if node != repo.nullid: | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _( | _( | ||||
| from ..node import ( | from ..node import ( | ||||
| nullrev, | nullrev, | ||||
| sha1nodeconstants, | sha1nodeconstants, | ||||
| ) | ) | ||||
| from ..thirdparty import attr | from ..thirdparty import attr | ||||
| from .. import ( | from .. import ( | ||||
| error, | error, | ||||
| pycompat, | |||||
| revlogutils, | revlogutils, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from ..revlogutils import nodemap as nodemaputil | from ..revlogutils import nodemap as nodemaputil | ||||
| from ..revlogutils import constants as revlog_constants | from ..revlogutils import constants as revlog_constants | ||||
| stringio = io.BytesIO | stringio = io.BytesIO | ||||
| dmap[f] = DirstateItem.from_v1_data(*e[:4]) | dmap[f] = DirstateItem.from_v1_data(*e[:4]) | ||||
| return parents | return parents | ||||
| def pack_dirstate(dmap, copymap, pl): | def pack_dirstate(dmap, copymap, pl): | ||||
| cs = stringio() | cs = stringio() | ||||
| write = cs.write | write = cs.write | ||||
| write(b"".join(pl)) | write(b"".join(pl)) | ||||
| for f, e in pycompat.iteritems(dmap): | for f, e in dmap.items(): | ||||
| if f in copymap: | if f in copymap: | ||||
| f = b"%s\0%s" % (f, copymap[f]) | f = b"%s\0%s" % (f, copymap[f]) | ||||
| e = _pack( | e = _pack( | ||||
| b">cllll", | b">cllll", | ||||
| e.v1_state(), | e.v1_state(), | ||||
| e.v1_mode(), | e.v1_mode(), | ||||
| e.v1_size(), | e.v1_size(), | ||||
| e.v1_mtime(), | e.v1_mtime(), | ||||
| len(f), | len(f), | ||||
| ) | ) | ||||
| write(e) | write(e) | ||||
| write(f) | write(f) | ||||
| return cs.getvalue() | return cs.getvalue() | ||||
| elif ancestors is None: | elif ancestors is None: | ||||
| # Otherwise, we're trying to discover the heads. | # Otherwise, we're trying to discover the heads. | ||||
| # Assume this is a head because if it isn't, the next step | # Assume this is a head because if it isn't, the next step | ||||
| # will eventually remove it. | # will eventually remove it. | ||||
| heads[n] = True | heads[n] = True | ||||
| # But, obviously its parents aren't. | # But, obviously its parents aren't. | ||||
| for p in self.parents(n): | for p in self.parents(n): | ||||
| heads.pop(p, None) | heads.pop(p, None) | ||||
| heads = [head for head, flag in pycompat.iteritems(heads) if flag] | heads = [head for head, flag in heads.items() if flag] | ||||
| roots = list(roots) | roots = list(roots) | ||||
| assert orderedout | assert orderedout | ||||
| assert roots | assert roots | ||||
| assert heads | assert heads | ||||
| return (orderedout, roots, heads) | return (orderedout, roots, heads) | ||||
| def headrevs(self, revs=None): | def headrevs(self, revs=None): | ||||
| if revs is None: | if revs is None: | ||||
| bmrev = repo._bookmarks.get(pattern, None) | bmrev = repo._bookmarks.get(pattern, None) | ||||
| if not bmrev: | if not bmrev: | ||||
| raise error.RepoLookupError( | raise error.RepoLookupError( | ||||
| _(b"bookmark '%s' does not exist") % pattern | _(b"bookmark '%s' does not exist") % pattern | ||||
| ) | ) | ||||
| bms.add(repo[bmrev].rev()) | bms.add(repo[bmrev].rev()) | ||||
| else: | else: | ||||
| matchrevs = set() | matchrevs = set() | ||||
| for name, bmrev in pycompat.iteritems(repo._bookmarks): | for name, bmrev in repo._bookmarks.items(): | ||||
| if matcher(name): | if matcher(name): | ||||
| matchrevs.add(bmrev) | matchrevs.add(bmrev) | ||||
| for bmrev in matchrevs: | for bmrev in matchrevs: | ||||
| bms.add(repo[bmrev].rev()) | bms.add(repo[bmrev].rev()) | ||||
| else: | else: | ||||
| bms = {repo[r].rev() for r in repo._bookmarks.values()} | bms = {repo[r].rev() for r in repo._bookmarks.values()} | ||||
| bms -= {nullrev} | bms -= {nullrev} | ||||
| return subset & bms | return subset & bms | ||||
| namespaces = set() | namespaces = set() | ||||
| if kind == b'literal': | if kind == b'literal': | ||||
| if pattern not in repo.names: | if pattern not in repo.names: | ||||
| raise error.RepoLookupError( | raise error.RepoLookupError( | ||||
| _(b"namespace '%s' does not exist") % ns | _(b"namespace '%s' does not exist") % ns | ||||
| ) | ) | ||||
| namespaces.add(repo.names[pattern]) | namespaces.add(repo.names[pattern]) | ||||
| else: | else: | ||||
| for name, ns in pycompat.iteritems(repo.names): | for name, ns in repo.names.items(): | ||||
| if matcher(name): | if matcher(name): | ||||
| namespaces.add(ns) | namespaces.add(ns) | ||||
| names = set() | names = set() | ||||
| for ns in namespaces: | for ns in namespaces: | ||||
| for name in ns.listnames(repo): | for name in ns.listnames(repo): | ||||
| if name not in ns.deprecated: | if name not in ns.deprecated: | ||||
| names.update(repo[n].rev() for n in ns.nodes(repo, name)) | names.update(repo[n].rev() for n in ns.nodes(repo, name)) | ||||
| subset = fullreposet(repo) | subset = fullreposet(repo) | ||||
| return getset(repo, subset, tree, order) | return getset(repo, subset, tree, order) | ||||
| return mfunc | return mfunc | ||||
| def loadpredicate(ui, extname, registrarobj): | def loadpredicate(ui, extname, registrarobj): | ||||
| """Load revset predicates from specified registrarobj""" | """Load revset predicates from specified registrarobj""" | ||||
| for name, func in pycompat.iteritems(registrarobj._table): | for name, func in registrarobj._table.items(): | ||||
| symbols[name] = func | symbols[name] = func | ||||
| if func._safe: | if func._safe: | ||||
| safesymbols.add(name) | safesymbols.add(name) | ||||
| # load built-in predicates explicitly to setup safesymbols | # load built-in predicates explicitly to setup safesymbols | ||||
| loadpredicate(None, None, predicate) | loadpredicate(None, None, predicate) | ||||
| # tell hggettext to extract docstrings from these functions: | # tell hggettext to extract docstrings from these functions: | ||||
| i18nfunctions = symbols.values() | i18nfunctions = symbols.values() | ||||
| def expandaliases(tree, aliases, warn=None): | def expandaliases(tree, aliases, warn=None): | ||||
| """Expand aliases in a tree, aliases is a list of (name, value) tuples""" | """Expand aliases in a tree, aliases is a list of (name, value) tuples""" | ||||
| aliases = _aliasrules.buildmap(aliases) | aliases = _aliasrules.buildmap(aliases) | ||||
| tree = _aliasrules.expand(aliases, tree) | tree = _aliasrules.expand(aliases, tree) | ||||
| # warn about problematic (but not referred) aliases | # warn about problematic (but not referred) aliases | ||||
| if warn is not None: | if warn is not None: | ||||
| for name, alias in sorted(pycompat.iteritems(aliases)): | for name, alias in sorted(aliases.items()): | ||||
| if alias.error and not alias.warned: | if alias.error and not alias.warned: | ||||
| warn(_(b'warning: %s\n') % (alias.error)) | warn(_(b'warning: %s\n') % (alias.error)) | ||||
| alias.warned = True | alias.warned = True | ||||
| return tree | return tree | ||||
| def foldconcat(tree): | def foldconcat(tree): | ||||
| """Fold elements to be concatenated by `##`""" | """Fold elements to be concatenated by `##`""" | ||||
| missing = set() | missing = set() | ||||
| for subpath in ctx2.substate: | for subpath in ctx2.substate: | ||||
| if subpath not in ctx1.substate: | if subpath not in ctx1.substate: | ||||
| del subpaths[subpath] | del subpaths[subpath] | ||||
| missing.add(subpath) | missing.add(subpath) | ||||
| for subpath, ctx in sorted(pycompat.iteritems(subpaths)): | for subpath, ctx in sorted(subpaths.items()): | ||||
| yield subpath, ctx.sub(subpath) | yield subpath, ctx.sub(subpath) | ||||
| # Yield an empty subrepo based on ctx1 for anything only in ctx2. That way, | # Yield an empty subrepo based on ctx1 for anything only in ctx2. That way, | ||||
| # status and diff will have an accurate result when it does | # status and diff will have an accurate result when it does | ||||
| # 'sub.{status|diff}(rev2)'. Otherwise, the ctx2 subrepo is compared | # 'sub.{status|diff}(rev2)'. Otherwise, the ctx2 subrepo is compared | ||||
| # against itself. | # against itself. | ||||
| for subpath in missing: | for subpath in missing: | ||||
| yield subpath, ctx2.nullsub(subpath, ctx1) | yield subpath, ctx2.nullsub(subpath, ctx1) | ||||
| matcher = repo.narrowmatch(matcher, includeexact=True) | matcher = repo.narrowmatch(matcher, includeexact=True) | ||||
| walkresults = dirstate.walk( | walkresults = dirstate.walk( | ||||
| matcher, | matcher, | ||||
| subrepos=sorted(ctx.substate), | subrepos=sorted(ctx.substate), | ||||
| unknown=True, | unknown=True, | ||||
| ignored=False, | ignored=False, | ||||
| full=False, | full=False, | ||||
| ) | ) | ||||
| for abs, st in pycompat.iteritems(walkresults): | for abs, st in walkresults.items(): | ||||
| entry = dirstate.get_entry(abs) | entry = dirstate.get_entry(abs) | ||||
| if (not entry.any_tracked) and audit_path.check(abs): | if (not entry.any_tracked) and audit_path.check(abs): | ||||
| unknown.append(abs) | unknown.append(abs) | ||||
| elif (not entry.removed) and not st: | elif (not entry.removed) and not st: | ||||
| deleted.append(abs) | deleted.append(abs) | ||||
| elif entry.removed and st: | elif entry.removed and st: | ||||
| forgotten.append(abs) | forgotten.append(abs) | ||||
| # for finding renames | # for finding renames | ||||
| def _markchanges(repo, unknown, deleted, renames): | def _markchanges(repo, unknown, deleted, renames): | ||||
| """Marks the files in unknown as added, the files in deleted as removed, | """Marks the files in unknown as added, the files in deleted as removed, | ||||
| and the files in renames as copied.""" | and the files in renames as copied.""" | ||||
| wctx = repo[None] | wctx = repo[None] | ||||
| with repo.wlock(): | with repo.wlock(): | ||||
| wctx.forget(deleted) | wctx.forget(deleted) | ||||
| wctx.add(unknown) | wctx.add(unknown) | ||||
| for new, old in pycompat.iteritems(renames): | for new, old in renames.items(): | ||||
| wctx.copy(old, new) | wctx.copy(old, new) | ||||
| def getrenamedfn(repo, endrev=None): | def getrenamedfn(repo, endrev=None): | ||||
| if copiesmod.usechangesetcentricalgo(repo): | if copiesmod.usechangesetcentricalgo(repo): | ||||
| def getrenamed(fn, rev): | def getrenamed(fn, rev): | ||||
| ctx = repo[rev] | ctx = repo[rev] | ||||
| ds.update_file_p1(f, p1_tracked=False) | ds.update_file_p1(f, p1_tracked=False) | ||||
| for f in s.removed: | for f in s.removed: | ||||
| ds.update_file_p1(f, p1_tracked=True) | ds.update_file_p1(f, p1_tracked=True) | ||||
| # Merge old parent and old working dir copies | # Merge old parent and old working dir copies | ||||
| oldcopies = copiesmod.pathcopies(newctx, oldctx, match) | oldcopies = copiesmod.pathcopies(newctx, oldctx, match) | ||||
| oldcopies.update(copies) | oldcopies.update(copies) | ||||
| copies = { | copies = {dst: oldcopies.get(src, src) for dst, src in oldcopies.items()} | ||||
| dst: oldcopies.get(src, src) | |||||
| for dst, src in pycompat.iteritems(oldcopies) | |||||
| } | |||||
| # Adjust the dirstate copies | # Adjust the dirstate copies | ||||
| for dst, src in pycompat.iteritems(copies): | for dst, src in copies.items(): | ||||
| if src not in newctx or dst in newctx or not ds.get_entry(dst).added: | if src not in newctx or dst in newctx or not ds.get_entry(dst).added: | ||||
| src = None | src = None | ||||
| ds.copy(src, dst) | ds.copy(src, dst) | ||||
| repo._quick_access_changeid_invalidate() | repo._quick_access_changeid_invalidate() | ||||
| def filterrequirements(requirements): | def filterrequirements(requirements): | ||||
| """filters the requirements into two sets: | """filters the requirements into two sets: | ||||
| # similar.py - mechanisms for finding similar files | # similar.py - mechanisms for finding similar files | ||||
| # | # | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from . import ( | from . import ( | ||||
| mdiff, | mdiff, | ||||
| pycompat, | |||||
| ) | ) | ||||
| def _findexactmatches(repo, added, removed): | def _findexactmatches(repo, added, removed): | ||||
| """find renamed files that have no changes | """find renamed files that have no changes | ||||
| Takes a list of new filectxs and a list of removed filectxs, and yields | Takes a list of new filectxs and a list of removed filectxs, and yields | ||||
| (before, after) tuples of exact matches. | (before, after) tuples of exact matches. | ||||
| bestscore = copies.get(a, (None, threshold))[1] | bestscore = copies.get(a, (None, threshold))[1] | ||||
| if data is None: | if data is None: | ||||
| data = _ctxdata(r) | data = _ctxdata(r) | ||||
| myscore = _score(a, data) | myscore = _score(a, data) | ||||
| if myscore > bestscore: | if myscore > bestscore: | ||||
| copies[a] = (r, myscore) | copies[a] = (r, myscore) | ||||
| progress.complete() | progress.complete() | ||||
| for dest, v in pycompat.iteritems(copies): | for dest, v in copies.items(): | ||||
| source, bscore = v | source, bscore = v | ||||
| yield source, dest, bscore | yield source, dest, bscore | ||||
| def _dropempty(fctxs): | def _dropempty(fctxs): | ||||
| return [x for x in fctxs if x.size() > 0] | return [x for x in fctxs if x.size() > 0] | ||||
| _( | _( | ||||
| b'cannot change sparseness due to pending ' | b'cannot change sparseness due to pending ' | ||||
| b'changes (delete the files or use ' | b'changes (delete the files or use ' | ||||
| b'--force to bring them back dirty)' | b'--force to bring them back dirty)' | ||||
| ) | ) | ||||
| ) | ) | ||||
| # Check for files that were only in the dirstate. | # Check for files that were only in the dirstate. | ||||
| for file, state in pycompat.iteritems(dirstate): | for file, state in dirstate.items(): | ||||
| if not file in files: | if not file in files: | ||||
| old = origsparsematch(file) | old = origsparsematch(file) | ||||
| new = sparsematch(file) | new = sparsematch(file) | ||||
| if old and not new: | if old and not new: | ||||
| dropped.append(file) | dropped.append(file) | ||||
| mergemod.applyupdates( | mergemod.applyupdates( | ||||
| repo, mresult, repo[None], repo[b'.'], False, wantfiledata=False | repo, mresult, repo[None], repo[b'.'], False, wantfiledata=False | ||||
| wireargs = {} | wireargs = {} | ||||
| for k in keys: | for k in keys: | ||||
| if k == b'*': | if k == b'*': | ||||
| wireargs[b'*'] = args | wireargs[b'*'] = args | ||||
| break | break | ||||
| else: | else: | ||||
| wireargs[k] = args[k] | wireargs[k] = args[k] | ||||
| del args[k] | del args[k] | ||||
| for k, v in sorted(pycompat.iteritems(wireargs)): | for k, v in sorted(wireargs.items()): | ||||
| self._pipeo.write(b"%s %d\n" % (k, len(v))) | self._pipeo.write(b"%s %d\n" % (k, len(v))) | ||||
| if isinstance(v, dict): | if isinstance(v, dict): | ||||
| for dk, dv in pycompat.iteritems(v): | for dk, dv in v.items(): | ||||
| self._pipeo.write(b"%s %d\n" % (dk, len(dv))) | self._pipeo.write(b"%s %d\n" % (dk, len(dv))) | ||||
| self._pipeo.write(dv) | self._pipeo.write(dv) | ||||
| else: | else: | ||||
| self._pipeo.write(v) | self._pipeo.write(v) | ||||
| self._pipeo.flush() | self._pipeo.flush() | ||||
| # We know exactly how many bytes are in the response. So return a proxy | # We know exactly how many bytes are in the response. So return a proxy | ||||
| # around the raw output stream that allows reading exactly this many | # around the raw output stream that allows reading exactly this many | ||||
| stats = SiteStats.buildstats(data.samples) | stats = SiteStats.buildstats(data.samples) | ||||
| grouped = defaultdict(list) | grouped = defaultdict(list) | ||||
| for stat in stats: | for stat in stats: | ||||
| grouped[stat.site.filename() + b":" + stat.site.function].append(stat) | grouped[stat.site.filename() + b":" + stat.site.function].append(stat) | ||||
| # compute sums for each function | # compute sums for each function | ||||
| functiondata = [] | functiondata = [] | ||||
| for fname, sitestats in pycompat.iteritems(grouped): | for fname, sitestats in grouped.items(): | ||||
| total_cum_sec = 0 | total_cum_sec = 0 | ||||
| total_self_sec = 0 | total_self_sec = 0 | ||||
| total_percent = 0 | total_percent = 0 | ||||
| for stat in sitestats: | for stat in sitestats: | ||||
| total_cum_sec += stat.totalseconds() | total_cum_sec += stat.totalseconds() | ||||
| total_self_sec += stat.selfseconds() | total_self_sec += stat.selfseconds() | ||||
| total_percent += stat.selfpercent() | total_percent += stat.selfpercent() | ||||
| else: | else: | ||||
| parents[parent] = 1 | parents[parent] = 1 | ||||
| if site in children: | if site in children: | ||||
| children[site] = children[site] + 1 | children[site] = children[site] + 1 | ||||
| else: | else: | ||||
| children[site] = 1 | children[site] = 1 | ||||
| parents = [(parent, count) for parent, count in pycompat.iteritems(parents)] | parents = [(parent, count) for parent, count in parents.items()] | ||||
| parents.sort(reverse=True, key=lambda x: x[1]) | parents.sort(reverse=True, key=lambda x: x[1]) | ||||
| for parent, count in parents: | for parent, count in parents: | ||||
| fp.write( | fp.write( | ||||
| b'%6.2f%% %s:%s line %s: %s\n' | b'%6.2f%% %s:%s line %s: %s\n' | ||||
| % ( | % ( | ||||
| count / relevant_samples * 100, | count / relevant_samples * 100, | ||||
| pycompat.fsencode(parent.filename()), | pycompat.fsencode(parent.filename()), | ||||
| pycompat.sysbytes(parent.function), | pycompat.sysbytes(parent.function), | ||||
| pycompat.sysbytes(function), | pycompat.sysbytes(function), | ||||
| total_cum_sec, | total_cum_sec, | ||||
| total_cum_percent, | total_cum_percent, | ||||
| total_self_sec, | total_self_sec, | ||||
| total_self_percent, | total_self_percent, | ||||
| ) | ) | ||||
| ) | ) | ||||
| children = [(child, count) for child, count in pycompat.iteritems(children)] | children = [(child, count) for child, count in children.items()] | ||||
| children.sort(reverse=True, key=lambda x: x[1]) | children.sort(reverse=True, key=lambda x: x[1]) | ||||
| for child, count in children: | for child, count in children: | ||||
| fp.write( | fp.write( | ||||
| b' %6.2f%% line %s: %s\n' | b' %6.2f%% line %s: %s\n' | ||||
| % ( | % ( | ||||
| count / relevant_samples * 100, | count / relevant_samples * 100, | ||||
| child.lineno, | child.lineno, | ||||
| pycompat.sysbytes(child.getsource(50)), | pycompat.sysbytes(child.getsource(50)), | ||||
| if line in lines: | if line in lines: | ||||
| lines[line] = lines[line] + 1 | lines[line] = lines[line] + 1 | ||||
| else: | else: | ||||
| lines[line] = 1 | lines[line] = 1 | ||||
| fd, path = pycompat.mkstemp() | fd, path = pycompat.mkstemp() | ||||
| with open(path, b"w+") as file: | with open(path, b"w+") as file: | ||||
| for line, count in pycompat.iteritems(lines): | for line, count in lines.items(): | ||||
| file.write(b"%s %d\n" % (line, count)) | file.write(b"%s %d\n" % (line, count)) | ||||
| if outputfile is None: | if outputfile is None: | ||||
| outputfile = b'~/flamegraph.svg' | outputfile = b'~/flamegraph.svg' | ||||
| os.system(b"perl ~/flamegraph.pl %s > %s" % (path, outputfile)) | os.system(b"perl ~/flamegraph.pl %s > %s" % (path, outputfile)) | ||||
| fp.write(b'Written to %s\n' % outputfile) | fp.write(b'Written to %s\n' % outputfile) | ||||
| cmap = {x: x for x in asciistr} | cmap = {x: x for x in asciistr} | ||||
| for x in _reserved(): | for x in _reserved(): | ||||
| cmap[xchr(x)] = b"~%02x" % x | cmap[xchr(x)] = b"~%02x" % x | ||||
| for x in capitals + [ord(e)]: | for x in capitals + [ord(e)]: | ||||
| cmap[xchr(x)] = e + xchr(x).lower() | cmap[xchr(x)] = e + xchr(x).lower() | ||||
| dmap = {} | dmap = {} | ||||
| for k, v in pycompat.iteritems(cmap): | for k, v in cmap.items(): | ||||
| dmap[v] = k | dmap[v] = k | ||||
| def decode(s): | def decode(s): | ||||
| i = 0 | i = 0 | ||||
| while i < len(s): | while i < len(s): | ||||
| for l in pycompat.xrange(1, 4): | for l in pycompat.xrange(1, 4): | ||||
| try: | try: | ||||
| yield dmap[s[i : i + l]] | yield dmap[s[i : i + l]] | ||||
| _(b"bookmark '%s' not found") | _(b"bookmark '%s' not found") | ||||
| % b','.join(sorted(bookmarks - set(repomarks.keys()))) | % b','.join(sorted(bookmarks - set(repomarks.keys()))) | ||||
| ) | ) | ||||
| # If the requested bookmark is not the only one pointing to a | # If the requested bookmark is not the only one pointing to a | ||||
| # a revision we have to only delete the bookmark and not strip | # a revision we have to only delete the bookmark and not strip | ||||
| # anything. revsets cannot detect that case. | # anything. revsets cannot detect that case. | ||||
| nodetobookmarks = {} | nodetobookmarks = {} | ||||
| for mark, node in pycompat.iteritems(repomarks): | for mark, node in repomarks.items(): | ||||
| nodetobookmarks.setdefault(node, []).append(mark) | nodetobookmarks.setdefault(node, []).append(mark) | ||||
| for marks in nodetobookmarks.values(): | for marks in nodetobookmarks.values(): | ||||
| if bookmarks.issuperset(marks): | if bookmarks.issuperset(marks): | ||||
| rsrevs = scmutil.bookmarkrevs(repo, marks[0]) | rsrevs = scmutil.bookmarkrevs(repo, marks[0]) | ||||
| revs.update(set(rsrevs)) | revs.update(set(rsrevs)) | ||||
| if not revs: | if not revs: | ||||
| with repo.lock(), repo.transaction(b'bookmark') as tr: | with repo.lock(), repo.transaction(b'bookmark') as tr: | ||||
| bmchanges = [(b, None) for b in bookmarks] | bmchanges = [(b, None) for b in bookmarks] | ||||
| if self._gitmissing(): | if self._gitmissing(): | ||||
| raise error.Abort(_(b"subrepo %s is missing") % self._relpath) | raise error.Abort(_(b"subrepo %s is missing") % self._relpath) | ||||
| # if a branch in origin contains the revision, nothing to do | # if a branch in origin contains the revision, nothing to do | ||||
| branch2rev, rev2branch = self._gitbranchmap() | branch2rev, rev2branch = self._gitbranchmap() | ||||
| if self._state[1] in rev2branch: | if self._state[1] in rev2branch: | ||||
| for b in rev2branch[self._state[1]]: | for b in rev2branch[self._state[1]]: | ||||
| if b.startswith(b'refs/remotes/origin/'): | if b.startswith(b'refs/remotes/origin/'): | ||||
| return True | return True | ||||
| for b, revision in pycompat.iteritems(branch2rev): | for b, revision in branch2rev.items(): | ||||
| if b.startswith(b'refs/remotes/origin/'): | if b.startswith(b'refs/remotes/origin/'): | ||||
| if self._gitisancestor(self._state[1], revision): | if self._gitisancestor(self._state[1], revision): | ||||
| return True | return True | ||||
| # otherwise, try to push the currently checked out branch | # otherwise, try to push the currently checked out branch | ||||
| cmd = [b'push'] | cmd = [b'push'] | ||||
| if force: | if force: | ||||
| cmd.append(b'--force') | cmd.append(b'--force') | ||||
| repo.ui.debug(b"subrepo merge %s %s %s\n" % (wctx, mctx, actx)) | repo.ui.debug(b"subrepo merge %s %s %s\n" % (wctx, mctx, actx)) | ||||
| def debug(s, msg, r=b""): | def debug(s, msg, r=b""): | ||||
| if r: | if r: | ||||
| r = b"%s:%s:%s" % r | r = b"%s:%s:%s" % r | ||||
| repo.ui.debug(b" subrepo %s: %s %s\n" % (s, msg, r)) | repo.ui.debug(b" subrepo %s: %s %s\n" % (s, msg, r)) | ||||
| promptssrc = filemerge.partextras(labels) | promptssrc = filemerge.partextras(labels) | ||||
| for s, l in sorted(pycompat.iteritems(s1)): | for s, l in sorted(s1.items()): | ||||
| a = sa.get(s, nullstate) | a = sa.get(s, nullstate) | ||||
| ld = l # local state with possible dirty flag for compares | ld = l # local state with possible dirty flag for compares | ||||
| if wctx.sub(s).dirty(): | if wctx.sub(s).dirty(): | ||||
| ld = (l[0], l[1] + b"+") | ld = (l[0], l[1] + b"+") | ||||
| if wctx == actx: # overwrite | if wctx == actx: # overwrite | ||||
| a = ld | a = ld | ||||
| prompts = promptssrc.copy() | prompts = promptssrc.copy() | ||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| match as matchmod, | match as matchmod, | ||||
| pycompat, | |||||
| scmutil, | scmutil, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from .utils import stringutil | from .utils import stringutil | ||||
| # Tags computation can be expensive and caches exist to make it fast in | # Tags computation can be expensive and caches exist to make it fast in | ||||
| # the common case. | # the common case. | ||||
| # | # | ||||
| The first one, 'alltags', is a "tagmaps" (see 'findglobaltags' for details). | The first one, 'alltags', is a "tagmaps" (see 'findglobaltags' for details). | ||||
| The second one, 'tagtypes', is optional and will be updated to track the | The second one, 'tagtypes', is optional and will be updated to track the | ||||
| "tagtype" of entries in the tagmaps. When set, the 'tagtype' argument also | "tagtype" of entries in the tagmaps. When set, the 'tagtype' argument also | ||||
| needs to be set.""" | needs to be set.""" | ||||
| if tagtype is None: | if tagtype is None: | ||||
| assert tagtypes is None | assert tagtypes is None | ||||
| for name, nodehist in pycompat.iteritems(filetags): | for name, nodehist in filetags.items(): | ||||
| if name not in alltags: | if name not in alltags: | ||||
| alltags[name] = nodehist | alltags[name] = nodehist | ||||
| if tagtype is not None: | if tagtype is not None: | ||||
| tagtypes[name] = tagtype | tagtypes[name] = tagtype | ||||
| continue | continue | ||||
| # we prefer alltags[name] if: | # we prefer alltags[name] if: | ||||
| # it supersedes us OR | # it supersedes us OR | ||||
| if flog.hasnode(fnode): | if flog.hasnode(fnode): | ||||
| validated_fnodes.add(fnode) | validated_fnodes.add(fnode) | ||||
| else: | else: | ||||
| unknown_entries.add(node) | unknown_entries.add(node) | ||||
| cachefnode[node] = fnode | cachefnode[node] = fnode | ||||
| if unknown_entries: | if unknown_entries: | ||||
| fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries) | fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries) | ||||
| for node, fnode in pycompat.iteritems(fixed_nodemap): | for node, fnode in fixed_nodemap.items(): | ||||
| if fnode != repo.nullid: | if fnode != repo.nullid: | ||||
| cachefnode[node] = fnode | cachefnode[node] = fnode | ||||
| fnodescache.write() | fnodescache.write() | ||||
| duration = util.timer() - starttime | duration = util.timer() - starttime | ||||
| ui.log( | ui.log( | ||||
| b'tagscache', | b'tagscache', | ||||
| ) | ) | ||||
| else: | else: | ||||
| cachefile.write(b'%d %s\n' % (valid[0], hex(valid[1]))) | cachefile.write(b'%d %s\n' % (valid[0], hex(valid[1]))) | ||||
| # Tag names in the cache are in UTF-8 -- which is the whole reason | # Tag names in the cache are in UTF-8 -- which is the whole reason | ||||
| # we keep them in UTF-8 throughout this module. If we converted | # we keep them in UTF-8 throughout this module. If we converted | ||||
| # them local encoding on input, we would lose info writing them to | # them local encoding on input, we would lose info writing them to | ||||
| # the cache. | # the cache. | ||||
| for (name, (node, hist)) in sorted(pycompat.iteritems(cachetags)): | for (name, (node, hist)) in sorted(cachetags.items()): | ||||
| for n in hist: | for n in hist: | ||||
| cachefile.write(b"%s %s\n" % (hex(n), name)) | cachefile.write(b"%s %s\n" % (hex(n), name)) | ||||
| cachefile.write(b"%s %s\n" % (hex(node), name)) | cachefile.write(b"%s %s\n" % (hex(node), name)) | ||||
| try: | try: | ||||
| cachefile.close() | cachefile.close() | ||||
| except (OSError, IOError): | except (OSError, IOError): | ||||
| pass | pass | ||||
| elif isinstance(obj, type(u'')): | elif isinstance(obj, type(u'')): | ||||
| raise error.ProgrammingError( | raise error.ProgrammingError( | ||||
| b'Mercurial only does output with bytes: %r' % obj | b'Mercurial only does output with bytes: %r' % obj | ||||
| ) | ) | ||||
| elif util.safehasattr(obj, b'keys'): | elif util.safehasattr(obj, b'keys'): | ||||
| out = [ | out = [ | ||||
| b'"%s": %s' | b'"%s": %s' | ||||
| % (encoding.jsonescape(k, paranoid=paranoid), json(v, paranoid)) | % (encoding.jsonescape(k, paranoid=paranoid), json(v, paranoid)) | ||||
| for k, v in sorted(pycompat.iteritems(obj)) | for k, v in sorted(obj.items()) | ||||
| ] | ] | ||||
| return b'{' + b', '.join(out) + b'}' | return b'{' + b', '.join(out) + b'}' | ||||
| elif util.safehasattr(obj, b'__iter__'): | elif util.safehasattr(obj, b'__iter__'): | ||||
| out = [json(i, paranoid) for i in obj] | out = [json(i, paranoid) for i in obj] | ||||
| return b'[' + b', '.join(out) + b']' | return b'[' + b', '.join(out) + b']' | ||||
| raise error.ProgrammingError(b'cannot encode %r' % obj) | raise error.ProgrammingError(b'cannot encode %r' % obj) | ||||
| if websubtable: | if websubtable: | ||||
| for regexp, format in websubtable: | for regexp, format in websubtable: | ||||
| text = regexp.sub(format, text) | text = regexp.sub(format, text) | ||||
| return text | return text | ||||
| def loadfilter(ui, extname, registrarobj): | def loadfilter(ui, extname, registrarobj): | ||||
| """Load template filter from specified registrarobj""" | """Load template filter from specified registrarobj""" | ||||
| for name, func in pycompat.iteritems(registrarobj._table): | for name, func in registrarobj._table.items(): | ||||
| filters[name] = func | filters[name] = func | ||||
| # tell hggettext to extract docstrings from these functions: | # tell hggettext to extract docstrings from these functions: | ||||
| i18nfunctions = filters.values() | i18nfunctions = filters.values() | ||||
| if num >= len(tokens) or num < -len(tokens): | if num >= len(tokens) or num < -len(tokens): | ||||
| return b'' | return b'' | ||||
| else: | else: | ||||
| return tokens[num] | return tokens[num] | ||||
| def loadfunction(ui, extname, registrarobj): | def loadfunction(ui, extname, registrarobj): | ||||
| """Load template function from specified registrarobj""" | """Load template function from specified registrarobj""" | ||||
| for name, func in pycompat.iteritems(registrarobj._table): | for name, func in registrarobj._table.items(): | ||||
| funcs[name] = func | funcs[name] = func | ||||
| # tell hggettext to extract docstrings from these functions: | # tell hggettext to extract docstrings from these functions: | ||||
| i18nfunctions = funcs.values() | i18nfunctions = funcs.values() | ||||
| ctx = context.resource(mapping, b'ctx') | ctx = context.resource(mapping, b'ctx') | ||||
| namespaces = util.sortdict() | namespaces = util.sortdict() | ||||
| def makensmapfn(ns): | def makensmapfn(ns): | ||||
| # 'name' for iterating over namespaces, templatename for local reference | # 'name' for iterating over namespaces, templatename for local reference | ||||
| return lambda v: {b'name': v, ns.templatename: v} | return lambda v: {b'name': v, ns.templatename: v} | ||||
| for k, ns in pycompat.iteritems(repo.names): | for k, ns in repo.names.items(): | ||||
| names = ns.names(repo, ctx.node()) | names = ns.names(repo, ctx.node()) | ||||
| f = _showcompatlist(context, mapping, b'name', names) | f = _showcompatlist(context, mapping, b'name', names) | ||||
| namespaces[k] = _hybrid(f, names, makensmapfn(ns), pycompat.identity) | namespaces[k] = _hybrid(f, names, makensmapfn(ns), pycompat.identity) | ||||
| f = _showcompatlist(context, mapping, b'namespace', list(namespaces)) | f = _showcompatlist(context, mapping, b'namespace', list(namespaces)) | ||||
| def makemap(ns): | def makemap(ns): | ||||
| return { | return { | ||||
| d = {b'name': k} | d = {b'name': k} | ||||
| if len(ps) == 1: | if len(ps) == 1: | ||||
| d[b'url'] = ps[0].rawloc | d[b'url'] = ps[0].rawloc | ||||
| sub_opts = pycompat.iteritems(ps[0].suboptions) | sub_opts = pycompat.iteritems(ps[0].suboptions) | ||||
| sub_opts = util.sortdict(sorted(sub_opts)) | sub_opts = util.sortdict(sorted(sub_opts)) | ||||
| d.update(sub_opts) | d.update(sub_opts) | ||||
| path_dict = util.sortdict() | path_dict = util.sortdict() | ||||
| for p in ps: | for p in ps: | ||||
| sub_opts = util.sortdict(sorted(pycompat.iteritems(p.suboptions))) | sub_opts = util.sortdict(sorted(p.suboptions.items())) | ||||
| path_dict[b'url'] = p.rawloc | path_dict[b'url'] = p.rawloc | ||||
| path_dict.update(sub_opts) | path_dict.update(sub_opts) | ||||
| d[b'urls'] = [path_dict] | d[b'urls'] = [path_dict] | ||||
| return d | return d | ||||
| def format_one(k): | def format_one(k): | ||||
| return b'%s=%s' % (k, urls[k]) | return b'%s=%s' % (k, urls[k]) | ||||
| b'{instability}:{if(divergentnodes, " ")}{divergentnodes} ' | b'{instability}:{if(divergentnodes, " ")}{divergentnodes} ' | ||||
| b'{reason} {node|short}' | b'{reason} {node|short}' | ||||
| ) | ) | ||||
| return templateutil.mappinglist(entries, tmpl=tmpl, sep=b'\n') | return templateutil.mappinglist(entries, tmpl=tmpl, sep=b'\n') | ||||
| def loadkeyword(ui, extname, registrarobj): | def loadkeyword(ui, extname, registrarobj): | ||||
| """Load template keyword from specified registrarobj""" | """Load template keyword from specified registrarobj""" | ||||
| for name, func in pycompat.iteritems(registrarobj._table): | for name, func in registrarobj._table.items(): | ||||
| keywords[name] = func | keywords[name] = func | ||||
| # tell hggettext to extract docstrings from these functions: | # tell hggettext to extract docstrings from these functions: | ||||
| i18nfunctions = keywords.values() | i18nfunctions = keywords.values() | ||||
| ['l', 'k'] | ['l', 'k'] | ||||
| >>> args = fargs(b'a(opts=1, k=2)', b'**opts') | >>> args = fargs(b'a(opts=1, k=2)', b'**opts') | ||||
| >>> list(args.keys()), list(args[b'opts'].keys()) | >>> list(args.keys()), list(args[b'opts'].keys()) | ||||
| (['opts'], ['opts', 'k']) | (['opts'], ['opts', 'k']) | ||||
| """ | """ | ||||
| def compiledict(xs): | def compiledict(xs): | ||||
| return util.sortdict( | return util.sortdict( | ||||
| (k, compileexp(x, context, curmethods)) | (k, compileexp(x, context, curmethods)) for k, x in xs.items() | ||||
| for k, x in pycompat.iteritems(xs) | |||||
| ) | ) | ||||
| def compilelist(xs): | def compilelist(xs): | ||||
| return [compileexp(x, context, curmethods) for x in xs] | return [compileexp(x, context, curmethods) for x in xs] | ||||
| if not argspec: | if not argspec: | ||||
| # filter or function with no argspec: return list of positional args | # filter or function with no argspec: return list of positional args | ||||
| return compilelist(getlist(exp)) | return compilelist(getlist(exp)) | ||||
| """Create combined mapping from the original mapping and partial | """Create combined mapping from the original mapping and partial | ||||
| mapping to override the original""" | mapping to override the original""" | ||||
| # do not copy symbols which overrides the defaults depending on | # do not copy symbols which overrides the defaults depending on | ||||
| # new resources, so the defaults will be re-evaluated (issue5612) | # new resources, so the defaults will be re-evaluated (issue5612) | ||||
| knownres = self._resources.knownkeys() | knownres = self._resources.knownkeys() | ||||
| newres = self._resources.availablekeys(newmapping) | newres = self._resources.availablekeys(newmapping) | ||||
| mapping = { | mapping = { | ||||
| k: v | k: v | ||||
| for k, v in pycompat.iteritems(origmapping) | for k, v in origmapping.items() | ||||
| if ( | if ( | ||||
| k in knownres # not a symbol per self.symbol() | k in knownres # not a symbol per self.symbol() | ||||
| or newres.isdisjoint(self._defaultrequires(k)) | or newres.isdisjoint(self._defaultrequires(k)) | ||||
| ) | ) | ||||
| } | } | ||||
| mapping.update(newmapping) | mapping.update(newmapping) | ||||
| mapping.update( | mapping.update( | ||||
| self._resources.populatemap(self, origmapping, newmapping) | self._resources.populatemap(self, origmapping, newmapping) | ||||
| # a nested hybrid list/dict, which has its own way of map operation | # a nested hybrid list/dict, which has its own way of map operation | ||||
| return val | return val | ||||
| return hybriditem(None, key, val, self._makemap) | return hybriditem(None, key, val, self._makemap) | ||||
| def filter(self, context, mapping, select): | def filter(self, context, mapping, select): | ||||
| if util.safehasattr(self._values, b'get'): | if util.safehasattr(self._values, b'get'): | ||||
| values = { | values = { | ||||
| k: v | k: v | ||||
| for k, v in pycompat.iteritems(self._values) | for k, v in self._values.items() | ||||
| if select(self._wrapvalue(k, v)) | if select(self._wrapvalue(k, v)) | ||||
| } | } | ||||
| else: | else: | ||||
| values = [v for v in self._values if select(self._wrapvalue(v, v))] | values = [v for v in self._values if select(self._wrapvalue(v, v))] | ||||
| return hybrid(None, values, self._makemap, self._joinfmt, self._keytype) | return hybrid(None, values, self._makemap, self._joinfmt, self._keytype) | ||||
| def itermaps(self, context): | def itermaps(self, context): | ||||
| makemap = self._makemap | makemap = self._makemap | ||||
| def tobool(self, context, mapping): | def tobool(self, context, mapping): | ||||
| return bool(self._values) | return bool(self._values) | ||||
| def tovalue(self, context, mapping): | def tovalue(self, context, mapping): | ||||
| # TODO: make it non-recursive for trivial lists/dicts | # TODO: make it non-recursive for trivial lists/dicts | ||||
| xs = self._values | xs = self._values | ||||
| if util.safehasattr(xs, b'get'): | if util.safehasattr(xs, b'get'): | ||||
| return { | return {k: unwrapvalue(context, mapping, v) for k, v in xs.items()} | ||||
| k: unwrapvalue(context, mapping, v) | |||||
| for k, v in pycompat.iteritems(xs) | |||||
| } | |||||
| return [unwrapvalue(context, mapping, x) for x in xs] | return [unwrapvalue(context, mapping, x) for x in xs] | ||||
| class hybriditem(mappable, wrapped): | class hybriditem(mappable, wrapped): | ||||
| """Wrapper for non-list/dict object to support map operation | """Wrapper for non-list/dict object to support map operation | ||||
| This class allows us to handle both: | This class allows us to handle both: | ||||
| - "{manifest}" | - "{manifest}" | ||||
| knownres = context.knownresourcekeys() | knownres = context.knownresourcekeys() | ||||
| items = [] | items = [] | ||||
| for nm in self.itermaps(context): | for nm in self.itermaps(context): | ||||
| # drop internal resources (recursively) which shouldn't be displayed | # drop internal resources (recursively) which shouldn't be displayed | ||||
| lm = context.overlaymap(mapping, nm) | lm = context.overlaymap(mapping, nm) | ||||
| items.append( | items.append( | ||||
| { | { | ||||
| k: unwrapvalue(context, lm, v) | k: unwrapvalue(context, lm, v) | ||||
| for k, v in pycompat.iteritems(nm) | for k, v in nm.items() | ||||
| if k not in knownres | if k not in knownres | ||||
| } | } | ||||
| ) | ) | ||||
| return items | return items | ||||
| class mappinggenerator(_mappingsequence): | class mappinggenerator(_mappingsequence): | ||||
| """Wrapper for generator of template mappings | """Wrapper for generator of template mappings | ||||
| plural=None, | plural=None, | ||||
| separator=b' ', | separator=b' ', | ||||
| ): | ): | ||||
| """Wrap data like hybriddict(), but also supports old-style list template | """Wrap data like hybriddict(), but also supports old-style list template | ||||
| This exists for backward compatibility with the old-style template. Use | This exists for backward compatibility with the old-style template. Use | ||||
| hybriddict() for new template keywords. | hybriddict() for new template keywords. | ||||
| """ | """ | ||||
| c = [{key: k, value: v} for k, v in pycompat.iteritems(data)] | c = [{key: k, value: v} for k, v in data.items()] | ||||
| f = _showcompatlist(context, mapping, name, c, plural, separator) | f = _showcompatlist(context, mapping, name, c, plural, separator) | ||||
| return hybriddict(data, key=key, value=value, fmt=fmt, gen=f) | return hybriddict(data, key=key, value=value, fmt=fmt, gen=f) | ||||
| def compatlist( | def compatlist( | ||||
| context, | context, | ||||
| mapping, | mapping, | ||||
| name, | name, | ||||
| any = False | any = False | ||||
| if group == GEN_GROUP_ALL: | if group == GEN_GROUP_ALL: | ||||
| skip_post = skip_pre = False | skip_post = skip_pre = False | ||||
| else: | else: | ||||
| skip_pre = group == GEN_GROUP_POST_FINALIZE | skip_pre = group == GEN_GROUP_POST_FINALIZE | ||||
| skip_post = group == GEN_GROUP_PRE_FINALIZE | skip_post = group == GEN_GROUP_PRE_FINALIZE | ||||
| for id, entry in sorted(pycompat.iteritems(self._filegenerators)): | for id, entry in sorted(self._filegenerators.items()): | ||||
| any = True | any = True | ||||
| order, filenames, genfunc, location, post_finalize = entry | order, filenames, genfunc, location, post_finalize = entry | ||||
| # for generation at closing, check if it's before or after finalize | # for generation at closing, check if it's before or after finalize | ||||
| if skip_post and post_finalize: | if skip_post and post_finalize: | ||||
| continue | continue | ||||
| elif skip_pre and not post_finalize: | elif skip_pre and not post_finalize: | ||||
| continue | continue | ||||
| def _generic_proxytunnel(self): | def _generic_proxytunnel(self): | ||||
| proxyheaders = { | proxyheaders = { | ||||
| pycompat.bytestr(x): pycompat.bytestr(self.headers[x]) | pycompat.bytestr(x): pycompat.bytestr(self.headers[x]) | ||||
| for x in self.headers | for x in self.headers | ||||
| if x.lower().startswith('proxy-') | if x.lower().startswith('proxy-') | ||||
| } | } | ||||
| self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport) | self.send(b'CONNECT %s HTTP/1.0\r\n' % self.realhostport) | ||||
| for header in pycompat.iteritems(proxyheaders): | for header in proxyheaders.items(): | ||||
| self.send(b'%s: %s\r\n' % header) | self.send(b'%s: %s\r\n' % header) | ||||
| self.send(b'\r\n') | self.send(b'\r\n') | ||||
| # majority of the following code is duplicated from | # majority of the following code is duplicated from | ||||
| # httplib.HTTPConnection as there are no adequate places to | # httplib.HTTPConnection as there are no adequate places to | ||||
| # override functions to provide the needed functionality. | # override functions to provide the needed functionality. | ||||
| res = self.response_class(self.sock, method=self._method) | res = self.response_class(self.sock, method=self._method) | ||||
| if key in self: | if key in self: | ||||
| del self[key] | del self[key] | ||||
| super(sortdict, self).__setitem__(key, value) | super(sortdict, self).__setitem__(key, value) | ||||
| if pycompat.ispypy: | if pycompat.ispypy: | ||||
| # __setitem__() isn't called as of PyPy 5.8.0 | # __setitem__() isn't called as of PyPy 5.8.0 | ||||
| def update(self, src, **f): | def update(self, src, **f): | ||||
| if isinstance(src, dict): | if isinstance(src, dict): | ||||
| src = pycompat.iteritems(src) | src = src.items() | ||||
| for k, v in src: | for k, v in src: | ||||
| self[k] = v | self[k] = v | ||||
| for k in f: | for k in f: | ||||
| self[k] = f[k] | self[k] = f[k] | ||||
| def insert(self, position, key, value): | def insert(self, position, key, value): | ||||
| for (i, (k, v)) in enumerate(list(self.items())): | for (i, (k, v)) in enumerate(list(self.items())): | ||||
| if i == position: | if i == position: | ||||
| def streamencodemap(d): | def streamencodemap(d): | ||||
| """Encode dictionary to a generator. | """Encode dictionary to a generator. | ||||
| Does not supporting indefinite length dictionaries. | Does not supporting indefinite length dictionaries. | ||||
| """ | """ | ||||
| yield encodelength(MAJOR_TYPE_MAP, len(d)) | yield encodelength(MAJOR_TYPE_MAP, len(d)) | ||||
| for key, value in sorted( | for key, value in sorted(d.items(), key=lambda x: _mixedtypesortkey(x[0])): | ||||
| pycompat.iteritems(d), key=lambda x: _mixedtypesortkey(x[0]) | |||||
| ): | |||||
| for chunk in streamencode(key): | for chunk in streamencode(key): | ||||
| yield chunk | yield chunk | ||||
| for chunk in streamencode(value): | for chunk in streamencode(value): | ||||
| yield chunk | yield chunk | ||||
| def streamencodemapfromiter(it): | def streamencodemapfromiter(it): | ||||
| """Given an iterable of (key, value), encode to an indefinite length map.""" | """Given an iterable of (key, value), encode to an indefinite length map.""" | ||||
| b'tempfile:': tempfilter, | b'tempfile:': tempfilter, | ||||
| b'pipe:': pipefilter, | b'pipe:': pipefilter, | ||||
| } | } | ||||
| def filter(s, cmd): | def filter(s, cmd): | ||||
| """filter a string through a command that transforms its input to its | """filter a string through a command that transforms its input to its | ||||
| output""" | output""" | ||||
| for name, fn in pycompat.iteritems(_filtertable): | for name, fn in _filtertable.items(): | ||||
| 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 | ||||
| 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: | ||||
| env.update((k, py2shell(v)) for k, v in pycompat.iteritems(environ)) | env.update((k, py2shell(v)) for k, v in environ.items()) | ||||
| env[b'HG'] = hgexecutable() | env[b'HG'] = hgexecutable() | ||||
| return env | return env | ||||
| if pycompat.iswindows: | if pycompat.iswindows: | ||||
| def shelltonative(cmd, env): | def shelltonative(cmd, env): | ||||
| return platform.shelltocmdexe( # pytype: disable=module-attr | return platform.shelltocmdexe( # pytype: disable=module-attr | ||||
| u.user = u.passwd = None | u.user = u.passwd = None | ||||
| return bytes(u) | return bytes(u) | ||||
| def list_paths(ui, target_path=None): | def list_paths(ui, target_path=None): | ||||
| """list all the (name, paths) in the passed ui""" | """list all the (name, paths) in the passed ui""" | ||||
| result = [] | result = [] | ||||
| if target_path is None: | if target_path is None: | ||||
| for name, paths in sorted(pycompat.iteritems(ui.paths)): | for name, paths in sorted(ui.paths.items()): | ||||
| for p in paths: | for p in paths: | ||||
| result.append((name, p)) | result.append((name, p)) | ||||
| else: | else: | ||||
| for path in ui.paths.get(target_path, []): | for path in ui.paths.get(target_path, []): | ||||
| result.append((target_path, path)) | result.append((target_path, path)) | ||||
| return result | return result | ||||
| b'location is not a URL or path to a local ' | b'location is not a URL or path to a local ' | ||||
| b'repo: %s' % self.rawloc | b'repo: %s' % self.rawloc | ||||
| ) | ) | ||||
| def _apply_suboptions(self, ui, sub_options): | def _apply_suboptions(self, ui, sub_options): | ||||
| # Now process the sub-options. If a sub-option is registered, its | # Now process the sub-options. If a sub-option is registered, its | ||||
| # attribute will always be present. The value will be None if there | # attribute will always be present. The value will be None if there | ||||
| # was no valid sub-option. | # was no valid sub-option. | ||||
| for suboption, (attr, func) in pycompat.iteritems(_pathsuboptions): | for suboption, (attr, func) in _pathsuboptions.items(): | ||||
| if suboption not in sub_options: | if suboption not in sub_options: | ||||
| setattr(self, attr, None) | setattr(self, attr, None) | ||||
| continue | continue | ||||
| value = func(ui, self, sub_options[suboption]) | value = func(ui, self, sub_options[suboption]) | ||||
| setattr(self, attr, value) | setattr(self, attr, value) | ||||
| def _isvalidlocalpath(self, path): | def _isvalidlocalpath(self, path): | ||||
| @property | @property | ||||
| def suboptions(self): | def suboptions(self): | ||||
| """Return sub-options and their values for this path. | """Return sub-options and their values for this path. | ||||
| This is intended to be used for presentation purposes. | This is intended to be used for presentation purposes. | ||||
| """ | """ | ||||
| d = {} | d = {} | ||||
| for subopt, (attr, _func) in pycompat.iteritems(_pathsuboptions): | for subopt, (attr, _func) in _pathsuboptions.items(): | ||||
| value = getattr(self, attr) | value = getattr(self, attr) | ||||
| if value is not None: | if value is not None: | ||||
| d[subopt] = value | d[subopt] = value | ||||
| return d | return d | ||||
| storefiles.add(_normpath(f)) | storefiles.add(_normpath(f)) | ||||
| subdirs.add(os.path.dirname(f)) | subdirs.add(os.path.dirname(f)) | ||||
| for f in undecodable: | for f in undecodable: | ||||
| self._err(None, _(b"cannot decode filename '%s'") % f) | self._err(None, _(b"cannot decode filename '%s'") % f) | ||||
| subdirprogress = ui.makeprogress( | subdirprogress = ui.makeprogress( | ||||
| _(b'checking'), unit=_(b'manifests'), total=len(subdirs) | _(b'checking'), unit=_(b'manifests'), total=len(subdirs) | ||||
| ) | ) | ||||
| for subdir, linkrevs in pycompat.iteritems(subdirnodes): | for subdir, linkrevs in subdirnodes.items(): | ||||
| subdirfilenodes = self._verifymanifest( | subdirfilenodes = self._verifymanifest( | ||||
| linkrevs, subdir, storefiles, subdirprogress | linkrevs, subdir, storefiles, subdirprogress | ||||
| ) | ) | ||||
| for f, onefilenodes in pycompat.iteritems(subdirfilenodes): | for f, onefilenodes in subdirfilenodes.items(): | ||||
| filenodes.setdefault(f, {}).update(onefilenodes) | filenodes.setdefault(f, {}).update(onefilenodes) | ||||
| if not dir and subdirnodes: | if not dir and subdirnodes: | ||||
| assert subdirprogress is not None # help pytype | assert subdirprogress is not None # help pytype | ||||
| subdirprogress.complete() | subdirprogress.complete() | ||||
| if self.warnorphanstorefiles: | if self.warnorphanstorefiles: | ||||
| for f in sorted(storefiles): | for f in sorted(storefiles): | ||||
| self._warn(_(b"warning: orphan data file '%s'") % f) | self._warn(_(b"warning: orphan data file '%s'") % f) | ||||
| FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS, | FRAME_TYPE_STREAM_SETTINGS: FLAGS_STREAM_ENCODING_SETTINGS, | ||||
| } | } | ||||
| ARGUMENT_RECORD_HEADER = struct.Struct('<HH') | ARGUMENT_RECORD_HEADER = struct.Struct('<HH') | ||||
| def humanflags(mapping, value): | def humanflags(mapping, value): | ||||
| """Convert a numeric flags value to a human value, using a mapping table.""" | """Convert a numeric flags value to a human value, using a mapping table.""" | ||||
| namemap = {v: k for k, v in pycompat.iteritems(mapping)} | namemap = {v: k for k, v in mapping.items()} | ||||
| flags = [] | flags = [] | ||||
| val = 1 | val = 1 | ||||
| while value >= val: | while value >= val: | ||||
| if value & val: | if value & val: | ||||
| flags.append(namemap.get(val, b'<unknown 0x%02x>' % val)) | flags.append(namemap.get(val, b'<unknown 0x%02x>' % val)) | ||||
| val <<= 1 | val <<= 1 | ||||
| return b'|'.join(flags) | return b'|'.join(flags) | ||||
| streamflags = attr.ib() | streamflags = attr.ib() | ||||
| typeid = attr.ib() | typeid = attr.ib() | ||||
| flags = attr.ib() | flags = attr.ib() | ||||
| payload = attr.ib() | payload = attr.ib() | ||||
| @encoding.strmethod | @encoding.strmethod | ||||
| def __repr__(self): | def __repr__(self): | ||||
| typename = b'<unknown 0x%02x>' % self.typeid | typename = b'<unknown 0x%02x>' % self.typeid | ||||
| for name, value in pycompat.iteritems(FRAME_TYPES): | for name, value in FRAME_TYPES.items(): | ||||
| if value == self.typeid: | if value == self.typeid: | ||||
| typename = name | typename = name | ||||
| break | break | ||||
| return ( | return ( | ||||
| b'frame(size=%d; request=%d; stream=%d; streamflags=%s; ' | b'frame(size=%d; request=%d; stream=%d; streamflags=%s; ' | ||||
| b'type=%s; flags=%s)' | b'type=%s; flags=%s)' | ||||
| % ( | % ( | ||||
| cmds = [] | cmds = [] | ||||
| for op, argsdict in req: | for op, argsdict in req: | ||||
| # Old servers didn't properly unescape argument names. So prevent | # Old servers didn't properly unescape argument names. So prevent | ||||
| # the sending of argument names that may not be decoded properly by | # the sending of argument names that may not be decoded properly by | ||||
| # servers. | # servers. | ||||
| assert all(escapearg(k) == k for k in argsdict) | assert all(escapearg(k) == k for k in argsdict) | ||||
| args = b','.join( | args = b','.join( | ||||
| b'%s=%s' % (escapearg(k), escapearg(v)) | b'%s=%s' % (escapearg(k), escapearg(v)) for k, v in argsdict.items() | ||||
| for k, v in pycompat.iteritems(argsdict) | |||||
| ) | ) | ||||
| cmds.append(b'%s %s' % (op, args)) | cmds.append(b'%s %s' % (op, args)) | ||||
| return b';'.join(cmds) | return b';'.join(cmds) | ||||
| class unsentfuture(futures.Future): | class unsentfuture(futures.Future): | ||||
| """A Future variation to represent an unsent command. | """A Future variation to represent an unsent command. | ||||
| def stream_out(self): | def stream_out(self): | ||||
| return self._callstream(b'stream_out') | return self._callstream(b'stream_out') | ||||
| def getbundle(self, source, **kwargs): | def getbundle(self, source, **kwargs): | ||||
| kwargs = pycompat.byteskwargs(kwargs) | kwargs = pycompat.byteskwargs(kwargs) | ||||
| self.requirecap(b'getbundle', _(b'look up remote changes')) | self.requirecap(b'getbundle', _(b'look up remote changes')) | ||||
| opts = {} | opts = {} | ||||
| bundlecaps = kwargs.get(b'bundlecaps') or set() | bundlecaps = kwargs.get(b'bundlecaps') or set() | ||||
| for key, value in pycompat.iteritems(kwargs): | for key, value in kwargs.items(): | ||||
| if value is None: | if value is None: | ||||
| continue | continue | ||||
| keytype = wireprototypes.GETBUNDLE_ARGUMENTS.get(key) | keytype = wireprototypes.GETBUNDLE_ARGUMENTS.get(key) | ||||
| if keytype is None: | if keytype is None: | ||||
| raise error.ProgrammingError( | raise error.ProgrammingError( | ||||
| b'Unexpectedly None keytype for key %s' % key | b'Unexpectedly None keytype for key %s' % key | ||||
| ) | ) | ||||
| elif keytype == b'nodes': | elif keytype == b'nodes': | ||||
| return wireprototypes.bytesresponse(b''.join(r)) | return wireprototypes.bytesresponse(b''.join(r)) | ||||
| @wireprotocommand(b'branchmap', permission=b'pull') | @wireprotocommand(b'branchmap', permission=b'pull') | ||||
| def branchmap(repo, proto): | def branchmap(repo, proto): | ||||
| branchmap = repo.branchmap() | branchmap = repo.branchmap() | ||||
| heads = [] | heads = [] | ||||
| for branch, nodes in pycompat.iteritems(branchmap): | for branch, nodes in branchmap.items(): | ||||
| branchname = urlreq.quote(encoding.fromlocal(branch)) | branchname = urlreq.quote(encoding.fromlocal(branch)) | ||||
| branchnodes = wireprototypes.encodelist(nodes) | branchnodes = wireprototypes.encodelist(nodes) | ||||
| heads.append(b'%s %s' % (branchname, branchnodes)) | heads.append(b'%s %s' % (branchname, branchnodes)) | ||||
| return wireprototypes.bytesresponse(b'\n'.join(heads)) | return wireprototypes.bytesresponse(b'\n'.join(heads)) | ||||
| @wireprotocommand(b'branches', b'nodes', permission=b'pull') | @wireprotocommand(b'branches', b'nodes', permission=b'pull') | ||||
| return None | return None | ||||
| @wireprotocommand(b'getbundle', b'*', permission=b'pull') | @wireprotocommand(b'getbundle', b'*', permission=b'pull') | ||||
| def getbundle(repo, proto, others): | def getbundle(repo, proto, others): | ||||
| opts = options( | opts = options( | ||||
| b'getbundle', wireprototypes.GETBUNDLE_ARGUMENTS.keys(), others | b'getbundle', wireprototypes.GETBUNDLE_ARGUMENTS.keys(), others | ||||
| ) | ) | ||||
| for k, v in pycompat.iteritems(opts): | for k, v in opts.items(): | ||||
| keytype = wireprototypes.GETBUNDLE_ARGUMENTS[k] | keytype = wireprototypes.GETBUNDLE_ARGUMENTS[k] | ||||
| if keytype == b'nodes': | if keytype == b'nodes': | ||||
| opts[k] = wireprototypes.decodelist(v) | opts[k] = wireprototypes.decodelist(v) | ||||
| elif keytype == b'csv': | elif keytype == b'csv': | ||||
| opts[k] = list(v.split(b',')) | opts[k] = list(v.split(b',')) | ||||
| elif keytype == b'scsv': | elif keytype == b'scsv': | ||||
| opts[k] = set(v.split(b',')) | opts[k] = set(v.split(b',')) | ||||
| elif keytype == b'boolean': | elif keytype == b'boolean': | ||||