| yuja |
| hg-reviewers |
My code editor was spewing several warnings for redundant
parenthesis. It supports easily fixing them. So I just did it
globally.
What redundant parenthesis are left are in 3rd party code or
are needed around string literals so our style checker doesn't
complain about the lack of _().
| Lint Skipped |
| Unit Tests Skipped |
I used my editor's feature to fix violations. That's probably what introduced the whitespace changes. If only Mercurial conformed to PEP-8 style...
| # First argument is callback function. This doesn't parse robustly | # First argument is callback function. This doesn't parse robustly | ||||
| # if it is e.g. a function call. | # if it is e.g. a function call. | ||||
| [^,]+,\s* | [^,]+,\s* | ||||
| ['"](?P<section>\S+)['"],\s* | ['"](?P<section>\S+)['"],\s* | ||||
| ['"](?P<option>\S+)['"](,\s+ | ['"](?P<option>\S+)['"](,\s+ | ||||
| (?:default=)?(?P<default>\S+?))? | (?:default=)?(?P<default>\S+?))? | ||||
| \)''', re.VERBOSE | re.MULTILINE) | \)''', re.VERBOSE | re.MULTILINE) | ||||
| configpartialre = (r"""ui\.config""") | configpartialre = r"""ui\.config""" | ||||
| ignorere = re.compile(r''' | ignorere = re.compile(r''' | ||||
| \#\s(?P<reason>internal|experimental|deprecated|developer|inconsistent)\s | \#\s(?P<reason>internal|experimental|deprecated|developer|inconsistent)\s | ||||
| config:\s(?P<config>\S+\.\S+)$ | config:\s(?P<config>\S+\.\S+)$ | ||||
| ''', re.VERBOSE | re.MULTILINE) | ''', re.VERBOSE | re.MULTILINE) | ||||
| def main(args): | def main(args): | ||||
| for f in args: | for f in args: | ||||
| # Check relative name first. | # Check relative name first. | ||||
| candidates = [prefix + name, name] | candidates = [prefix + name, name] | ||||
| else: | else: | ||||
| candidates = ['.'.join(modulename.split('.')[:-level]) + | candidates = ['.'.join(modulename.split('.')[:-level]) + | ||||
| '.' + name] | '.' + name] | ||||
| for n in candidates: | for n in candidates: | ||||
| if n in localmods: | if n in localmods: | ||||
| return (n, n, False) | return n, n, False | ||||
| dottedpath = n + '.__init__' | dottedpath = n + '.__init__' | ||||
| if dottedpath in localmods: | if dottedpath in localmods: | ||||
| return (n, dottedpath, True) | return n, dottedpath, True | ||||
| return False | return False | ||||
| return fromlocal | return fromlocal | ||||
| def populateextmods(localmods): | def populateextmods(localmods): | ||||
| """Populate C extension modules based on pure modules""" | """Populate C extension modules based on pure modules""" | ||||
| newlocalmods = set(localmods) | newlocalmods = set(localmods) | ||||
| for n in localmods: | for n in localmods: | ||||
| if n.startswith('mercurial.pure.'): | if n.startswith('mercurial.pure.'): | ||||
| # The last name to be imported (for sorting). | # The last name to be imported (for sorting). | ||||
| lastname = None | lastname = None | ||||
| laststdlib = None | laststdlib = None | ||||
| # Relative import levels encountered so far. | # Relative import levels encountered so far. | ||||
| seenlevels = set() | seenlevels = set() | ||||
| for node, newscope in walklocal(root): | for node, newscope in walklocal(root): | ||||
| def msg(fmt, *args): | def msg(fmt, *args): | ||||
| return (fmt % args, node.lineno) | return fmt % args, node.lineno | ||||
| if newscope: | if newscope: | ||||
| # Check for local imports in function | # Check for local imports in function | ||||
| for r in verify_modern_convention(module, node, localmods, | for r in verify_modern_convention(module, node, localmods, | ||||
| node.col_offset + 4): | node.col_offset + 4): | ||||
| yield r | yield r | ||||
| elif isinstance(node, ast.Import): | elif isinstance(node, ast.Import): | ||||
| # Disallow "import foo, bar" and require separate imports | # Disallow "import foo, bar" and require separate imports | ||||
| # for each module. | # for each module. | ||||
| # for "historical portability": | # for "historical portability": | ||||
| # use locally defined option list, if debugrevlogopts isn't available, | # use locally defined option list, if debugrevlogopts isn't available, | ||||
| # because commands.debugrevlogopts has been available since 3.7 (or | # because commands.debugrevlogopts has been available since 3.7 (or | ||||
| # 5606f7d0d063), even though cmdutil.openrevlog() has been available | # 5606f7d0d063), even though cmdutil.openrevlog() has been available | ||||
| # since 1.9 (or a79fea6b3e77). | # since 1.9 (or a79fea6b3e77). | ||||
| revlogopts = getattr(cmdutil, "debugrevlogopts", | revlogopts = getattr(cmdutil, "debugrevlogopts", | ||||
| getattr(commands, "debugrevlogopts", [ | getattr(commands, "debugrevlogopts", [ | ||||
| ('c', 'changelog', False, ('open changelog')), | ('c', 'changelog', False, 'open changelog'), | ||||
| ('m', 'manifest', False, ('open manifest')), | ('m', 'manifest', False, 'open manifest'), | ||||
| ('', 'dir', False, ('open directory manifest')), | ('', 'dir', False, 'open directory manifest'), | ||||
| ])) | ])) | ||||
| cmdtable = {} | cmdtable = {} | ||||
| # for "historical portability": | # for "historical portability": | ||||
| # define parsealiases locally, because cmdutil.parsealiases has been | # define parsealiases locally, because cmdutil.parsealiases has been | ||||
| # available since 1.5 (or 6252852b4332) | # available since 1.5 (or 6252852b4332) | ||||
| def parsealiases(cmd): | def parsealiases(cmd): | ||||
| """return the relative factor between values for 'field' in main and other | """return the relative factor between values for 'field' in main and other | ||||
| Return None if the factor is insignificant (less than <sensitivity> | Return None if the factor is insignificant (less than <sensitivity> | ||||
| variation).""" | variation).""" | ||||
| factor = 1 | factor = 1 | ||||
| if main is not None: | if main is not None: | ||||
| factor = other[field] / main[field] | factor = other[field] / main[field] | ||||
| low, high = 1 - sensitivity, 1 + sensitivity | low, high = 1 - sensitivity, 1 + sensitivity | ||||
| if (low < factor < high): | if low < factor < high: | ||||
| return None | return None | ||||
| return factor | return factor | ||||
| def formatfactor(factor): | def formatfactor(factor): | ||||
| """format a factor into a 4 char string | """format a factor into a 4 char string | ||||
| 22% | 22% | ||||
| 156% | 156% | ||||
| mark2level[m] = l | mark2level[m] = l | ||||
| initlevel_topic = 0 | initlevel_topic = 0 | ||||
| initlevel_cmd = 1 | initlevel_cmd = 1 | ||||
| initlevel_ext = 1 | initlevel_ext = 1 | ||||
| initlevel_ext_cmd = 3 | initlevel_ext_cmd = 3 | ||||
| def showavailables(ui, initlevel): | def showavailables(ui, initlevel): | ||||
| avail = (' available marks and order of them in this help: %s\n') % ( | avail = ' available marks and order of them in this help: %s\n' % ( | ||||
| ', '.join(['%r' % (m * 4) for m in level2mark[initlevel + 1:]])) | ', '.join(['%r' % (m * 4) for m in level2mark[initlevel + 1:]])) | ||||
| ui.warn(avail.encode('utf-8')) | ui.warn(avail.encode('utf-8')) | ||||
| def checkseclevel(ui, doc, name, initlevel): | def checkseclevel(ui, doc, name, initlevel): | ||||
| ui.note(('checking "%s"\n') % name) | ui.note(('checking "%s"\n') % name) | ||||
| if not isinstance(doc, bytes): | if not isinstance(doc, bytes): | ||||
| doc = doc.encode('utf-8') | doc = doc.encode('utf-8') | ||||
| blocks, pruned = minirst.parse(doc, 0, ['verbose']) | blocks, pruned = minirst.parse(doc, 0, ['verbose']) | ||||
| # this section unwraps lines | # this section unwraps lines | ||||
| match = leadingline.match(line) | match = leadingline.match(line) | ||||
| if not match: | if not match: | ||||
| check(lline) | check(lline) | ||||
| (llead, lline) = ('', '') | (llead, lline) = ('', '') | ||||
| continue | continue | ||||
| lead, line = match.group(1), match.group(2) | lead, line = match.group(1), match.group(2) | ||||
| if (lead == llead): | if lead == llead: | ||||
| if (lline != ''): | if lline != '': | ||||
| lline += ' ' + line | lline += ' ' + line | ||||
| else: | else: | ||||
| lline = line | lline = line | ||||
| else: | else: | ||||
| check(lline) | check(lline) | ||||
| (llead, lline) = (lead, line) | (llead, lline) = (lead, line) | ||||
| check(lline) | check(lline) | ||||
| i = docstr.find("\n") | i = docstr.find("\n") | ||||
| if i != -1: | if i != -1: | ||||
| desc = docstr[i + 2:] | desc = docstr[i + 2:] | ||||
| else: | else: | ||||
| desc = shortdesc | desc = shortdesc | ||||
| desc = textwrap.dedent(desc) | desc = textwrap.dedent(desc) | ||||
| return (shortdesc, desc) | return shortdesc, desc | ||||
| def get_opts(opts): | def get_opts(opts): | ||||
| for opt in opts: | for opt in opts: | ||||
| if len(opt) == 5: | if len(opt) == 5: | ||||
| shortopt, longopt, default, desc, optlabel = opt | shortopt, longopt, default, desc, optlabel = opt | ||||
| else: | else: | ||||
| shortopt, longopt, default, desc = opt | shortopt, longopt, default, desc = opt | ||||
| optlabel = _("VALUE") | optlabel = _("VALUE") | ||||
| .nr rst2man-indent-level -1 | .nr rst2man-indent-level -1 | ||||
| .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]] | .\" new: \\n[rst2man-indent\\n[rst2man-indent-level]] | ||||
| .in \\n[rst2man-indent\\n[rst2man-indent-level]]u | .in \\n[rst2man-indent\\n[rst2man-indent-level]]u | ||||
| .. | .. | ||||
| """) | """) | ||||
| class Writer(writers.Writer): | class Writer(writers.Writer): | ||||
| supported = ('manpage') | supported = 'manpage' | ||||
| """Formats this writer supports.""" | """Formats this writer supports.""" | ||||
| output = None | output = None | ||||
| """Final translated form of `document`.""" | """Final translated form of `document`.""" | ||||
| def __init__(self): | def __init__(self): | ||||
| writers.Writer.__init__(self) | writers.Writer.__init__(self) | ||||
| self.translator_class = Translator | self.translator_class = Translator | ||||
| start = 0 | start = 0 | ||||
| if len(cell_lines) > 0 and cell_lines[0] == '.sp\n': | if len(cell_lines) > 0 and cell_lines[0] == '.sp\n': | ||||
| start = 1 | start = 1 | ||||
| self._rows[-1].append(cell_lines[start:]) | self._rows[-1].append(cell_lines[start:]) | ||||
| if len(self._coldefs) < len(self._rows[-1]): | if len(self._coldefs) < len(self._rows[-1]): | ||||
| self._coldefs.append('l') | self._coldefs.append('l') | ||||
| def _minimize_cell(self, cell_lines): | def _minimize_cell(self, cell_lines): | ||||
| """Remove leading and trailing blank and ``.sp`` lines""" | """Remove leading and trailing blank and ``.sp`` lines""" | ||||
| while (cell_lines and cell_lines[0] in ('\n', '.sp\n')): | while cell_lines and cell_lines[0] in ('\n', '.sp\n'): | ||||
| del cell_lines[0] | del cell_lines[0] | ||||
| while (cell_lines and cell_lines[-1] in ('\n', '.sp\n')): | while cell_lines and cell_lines[-1] in ('\n', '.sp\n'): | ||||
| del cell_lines[-1] | del cell_lines[-1] | ||||
| def as_list(self): | def as_list(self): | ||||
| text = ['.TS\n'] | text = ['.TS\n'] | ||||
| text.append(' '.join(self._options) + ';\n') | text.append(' '.join(self._options) + ';\n') | ||||
| text.append('|%s|.\n' % ('|'.join(self._coldefs))) | text.append('|%s|.\n' % ('|'.join(self._coldefs))) | ||||
| for row in self._rows: | for row in self._rows: | ||||
| # row = array of cells. cell = array of lines. | # row = array of cells. cell = array of lines. | ||||
| text.append('_\n') # line above | text.append('_\n') # line above | ||||
| if not defaultuser: | if not defaultuser: | ||||
| raise error.Abort(_('cannot find bugzilla user id for %s') % | raise error.Abort(_('cannot find bugzilla user id for %s') % | ||||
| user) | user) | ||||
| userid = self.get_user_id(defaultuser) | userid = self.get_user_id(defaultuser) | ||||
| user = defaultuser | user = defaultuser | ||||
| except KeyError: | except KeyError: | ||||
| raise error.Abort(_('cannot find bugzilla user id for %s or %s') | raise error.Abort(_('cannot find bugzilla user id for %s or %s') | ||||
| % (user, defaultuser)) | % (user, defaultuser)) | ||||
| return (user, userid) | return user, userid | ||||
| def updatebug(self, bugid, newstate, text, committer): | def updatebug(self, bugid, newstate, text, committer): | ||||
| '''update bug state with comment text. | '''update bug state with comment text. | ||||
| Try adding comment as committer of changeset, otherwise as | Try adding comment as committer of changeset, otherwise as | ||||
| default bugzilla user.''' | default bugzilla user.''' | ||||
| if len(newstate) > 0: | if len(newstate) > 0: | ||||
| self.ui.warn(_("Bugzilla/MySQL cannot update bug state\n")) | self.ui.warn(_("Bugzilla/MySQL cannot update bug state\n")) | ||||
| added, removed = 0, 0 | added, removed = 0, 0 | ||||
| fmatch = scmutil.matchfiles(repo, fns) | fmatch = scmutil.matchfiles(repo, fns) | ||||
| diff = ''.join(patch.diff(repo, ctx1.node(), ctx2.node(), fmatch)) | diff = ''.join(patch.diff(repo, ctx1.node(), ctx2.node(), fmatch)) | ||||
| for l in diff.split('\n'): | for l in diff.split('\n'): | ||||
| if l.startswith("+") and not l.startswith("+++ "): | if l.startswith("+") and not l.startswith("+++ "): | ||||
| added += 1 | added += 1 | ||||
| elif l.startswith("-") and not l.startswith("--- "): | elif l.startswith("-") and not l.startswith("--- "): | ||||
| removed += 1 | removed += 1 | ||||
| return (added, removed) | return added, removed | ||||
| def countrate(ui, repo, amap, *pats, **opts): | def countrate(ui, repo, amap, *pats, **opts): | ||||
| """Calculate stats""" | """Calculate stats""" | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| if opts.get('dateformat'): | if opts.get('dateformat'): | ||||
| def getkey(ctx): | def getkey(ctx): | ||||
| t, tz = ctx.date() | t, tz = ctx.date() | ||||
| date = datetime.datetime(*time.gmtime(float(t) - tz)[:6]) | date = datetime.datetime(*time.gmtime(float(t) - tz)[:6]) | ||||
| # If branch is None or empty, this commit is coming from the source | # If branch is None or empty, this commit is coming from the source | ||||
| # repository's default branch and destined for the default branch in the | # repository's default branch and destined for the default branch in the | ||||
| # destination repository. For such commits, using a literal "default" | # destination repository. For such commits, using a literal "default" | ||||
| # in branchmap below allows the user to map "default" to an alternate | # in branchmap below allows the user to map "default" to an alternate | ||||
| # default branch in the destination repository. | # default branch in the destination repository. | ||||
| branch = branchmap.get(branch or 'default', branch) | branch = branchmap.get(branch or 'default', branch) | ||||
| # At some point we used "None" literal to denote the default branch, | # At some point we used "None" literal to denote the default branch, | ||||
| # attempt to use that for backward compatibility. | # attempt to use that for backward compatibility. | ||||
| if (not branch): | if not branch: | ||||
| branch = branchmap.get('None', branch) | branch = branchmap.get('None', branch) | ||||
| return branch | return branch | ||||
| source_converters = [ | source_converters = [ | ||||
| ('cvs', convert_cvs, 'branchsort'), | ('cvs', convert_cvs, 'branchsort'), | ||||
| ('git', convert_git, 'branchsort'), | ('git', convert_git, 'branchsort'), | ||||
| ('svn', svn_source, 'branchsort'), | ('svn', svn_source, 'branchsort'), | ||||
| ('hg', mercurial_source, 'sourcesort'), | ('hg', mercurial_source, 'sourcesort'), | ||||
| pass | pass | ||||
| elif line.startswith("Mbinary "): | elif line.startswith("Mbinary "): | ||||
| count = int(self.readp.readline()[:-1]) | count = int(self.readp.readline()[:-1]) | ||||
| data = chunkedread(self.readp, count) | data = chunkedread(self.readp, count) | ||||
| else: | else: | ||||
| if line == "ok\n": | if line == "ok\n": | ||||
| if mode is None: | if mode is None: | ||||
| raise error.Abort(_('malformed response from CVS')) | raise error.Abort(_('malformed response from CVS')) | ||||
| return (data, "x" in mode and "x" or "") | return data, "x" in mode and "x" or "" | ||||
| elif line.startswith("E "): | elif line.startswith("E "): | ||||
| self.ui.warn(_("cvs server: %s\n") % line[2:]) | self.ui.warn(_("cvs server: %s\n") % line[2:]) | ||||
| elif line.startswith("Remove"): | elif line.startswith("Remove"): | ||||
| self.readp.readline() | self.readp.readline() | ||||
| else: | else: | ||||
| raise error.Abort(_("unknown CVS response: %s") % line) | raise error.Abort(_("unknown CVS response: %s") % line) | ||||
| def getchanges(self, rev, full): | def getchanges(self, rev, full): | ||||
| entry = None | entry = None | ||||
| if subexists[0]: | if subexists[0]: | ||||
| if subdeleted[0]: | if subdeleted[0]: | ||||
| changes.append(('.hgsubstate', nodemod.nullhex)) | changes.append(('.hgsubstate', nodemod.nullhex)) | ||||
| else: | else: | ||||
| self.retrievegitmodules(version) | self.retrievegitmodules(version) | ||||
| changes.append(('.hgsubstate', '')) | changes.append(('.hgsubstate', '')) | ||||
| return (changes, copies, set()) | return changes, copies, set() | ||||
| def getcommit(self, version): | def getcommit(self, version): | ||||
| c = self.catfile(version, "commit") # read the commit hash | c = self.catfile(version, "commit") # read the commit hash | ||||
| end = c.find("\n\n") | end = c.find("\n\n") | ||||
| message = c[end + 2:] | message = c[end + 2:] | ||||
| message = self.recode(message) | message = self.recode(message) | ||||
| l = c[:end].splitlines() | l = c[:end].splitlines() | ||||
| parents = [] | parents = [] | ||||
| raise error.Abort(_('bad mtn packet - bad packet size %s') | raise error.Abort(_('bad mtn packet - bad packet size %s') | ||||
| % lengthstr) | % lengthstr) | ||||
| read = self.mtnreadfp.read(length) | read = self.mtnreadfp.read(length) | ||||
| if len(read) != length: | if len(read) != length: | ||||
| raise error.Abort(_("bad mtn packet - unable to read full packet " | raise error.Abort(_("bad mtn packet - unable to read full packet " | ||||
| "read %s of %s") % (len(read), length)) | "read %s of %s") % (len(read), length)) | ||||
| return (commandnbr, stream, length, read) | return commandnbr, stream, length, read | ||||
| def mtnstdioreadcommandoutput(self, command): | def mtnstdioreadcommandoutput(self, command): | ||||
| retval = [] | retval = [] | ||||
| while True: | while True: | ||||
| commandnbr, stream, length, output = self.mtnstdioreadpacket() | commandnbr, stream, length, output = self.mtnstdioreadpacket() | ||||
| self.ui.debug('mtn: read packet %s:%s:%s\n' % | self.ui.debug('mtn: read packet %s:%s:%s\n' % | ||||
| (commandnbr, stream, length)) | (commandnbr, stream, length)) | ||||
| self.ui.debug (_("copying file in renamed directory " | self.ui.debug (_("copying file in renamed directory " | ||||
| "from '%s' to '%s'") | "from '%s' to '%s'") | ||||
| % (fromfile, tofile), '\n') | % (fromfile, tofile), '\n') | ||||
| files[tofile] = rev | files[tofile] = rev | ||||
| copies[tofile] = fromfile | copies[tofile] = fromfile | ||||
| for fromfile in renamed.values(): | for fromfile in renamed.values(): | ||||
| files[fromfile] = rev | files[fromfile] = rev | ||||
| return (files.items(), copies, set()) | return files.items(), copies, set() | ||||
| def getfile(self, name, rev): | def getfile(self, name, rev): | ||||
| if not self.mtnisfile(name, rev): | if not self.mtnisfile(name, rev): | ||||
| return None, None | return None, None | ||||
| try: | try: | ||||
| data = self.mtnrun("get_file_of", name, r=rev) | data = self.mtnrun("get_file_of", name, r=rev) | ||||
| except Exception: | except Exception: | ||||
| return None, None | return None, None | ||||
| filename = None | filename = None | ||||
| for v in vieworder: | for v in vieworder: | ||||
| if oldname.lower().startswith(v.lower()): | if oldname.lower().startswith(v.lower()): | ||||
| filename = decodefilename(views[v] + oldname[len(v):]) | filename = decodefilename(views[v] + oldname[len(v):]) | ||||
| break | break | ||||
| if filename: | if filename: | ||||
| files.append((filename, d["rev%d" % i])) | files.append((filename, d["rev%d" % i])) | ||||
| depotname[filename] = oldname | depotname[filename] = oldname | ||||
| if (d.get("action%d" % i) == "move/add"): | if d.get("action%d" % i) == "move/add": | ||||
| copiedfiles.append(filename) | copiedfiles.append(filename) | ||||
| localname[oldname] = filename | localname[oldname] = filename | ||||
| i += 1 | i += 1 | ||||
| # Collect information about copied files | # Collect information about copied files | ||||
| for filename in copiedfiles: | for filename in copiedfiles: | ||||
| oldname = depotname[filename] | oldname = depotname[filename] | ||||
| entries = svn.client.ls(self.baseurl + quote(module), | entries = svn.client.ls(self.baseurl + quote(module), | ||||
| optrev(revnum), True, self.ctx) | optrev(revnum), True, self.ctx) | ||||
| files = [n for n, e in entries.iteritems() | files = [n for n, e in entries.iteritems() | ||||
| 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 = zip(files, [rev] * len(files)) | files = zip(files, [rev] * len(files)) | ||||
| return (files, copies) | return files, copies | ||||
| def getchanges(self, rev, full): | def getchanges(self, rev, full): | ||||
| # reuse cache from getchangedfiles | # reuse cache from getchangedfiles | ||||
| if self._changescache[0] == rev and not full: | if self._changescache[0] == rev and not full: | ||||
| (files, copies) = self._changescache[1] | (files, copies) = self._changescache[1] | ||||
| else: | else: | ||||
| (files, copies) = self._getchanges(rev, full) | (files, copies) = self._getchanges(rev, full) | ||||
| # caller caches the result, so free it here to release memory | # caller caches the result, so free it here to release memory | ||||
| del self.paths[rev] | del self.paths[rev] | ||||
| return (files, copies, set()) | return files, copies, set() | ||||
| def getchangedfiles(self, rev, i): | def getchangedfiles(self, rev, i): | ||||
| # called from filemap - cache computed values for reuse in getchanges | # called from filemap - cache computed values for reuse in getchanges | ||||
| (files, copies) = self._getchanges(rev, False) | (files, copies) = self._getchanges(rev, False) | ||||
| self._changescache = (rev, (files, copies)) | self._changescache = (rev, (files, copies)) | ||||
| return [f[0] for f in files] | return [f[0] for f in files] | ||||
| def getcommit(self, rev): | def getcommit(self, rev): | ||||
| if not childpath: | if not childpath: | ||||
| continue | continue | ||||
| copytopath = path + childpath[len(copyfrompath):] | copytopath = path + childpath[len(copyfrompath):] | ||||
| copytopath = self.getrelpath(copytopath) | copytopath = self.getrelpath(copytopath) | ||||
| copies[self.recode(copytopath)] = self.recode(childpath) | copies[self.recode(copytopath)] = self.recode(childpath) | ||||
| self.ui.progress(_('scanning paths'), None) | self.ui.progress(_('scanning paths'), None) | ||||
| changed.update(removed) | changed.update(removed) | ||||
| return (list(changed), removed, copies) | return list(changed), removed, copies | ||||
| def _fetch_revisions(self, from_revnum, to_revnum): | def _fetch_revisions(self, from_revnum, to_revnum): | ||||
| if from_revnum < to_revnum: | if from_revnum < to_revnum: | ||||
| from_revnum, to_revnum = to_revnum, from_revnum | from_revnum, to_revnum = to_revnum, from_revnum | ||||
| self.child_cset = None | self.child_cset = None | ||||
| def parselogentry(orig_paths, revnum, author, date, message): | def parselogentry(orig_paths, revnum, author, date, message): | ||||
| os.write(fd, 'read') | os.write(fd, 'read') | ||||
| status, user, passwd = os.read(fd, ERRMAX).split(None, 2) | status, user, passwd = os.read(fd, ERRMAX).split(None, 2) | ||||
| if status == 'ok': | if status == 'ok': | ||||
| if passwd.startswith("'"): | if passwd.startswith("'"): | ||||
| if passwd.endswith("'"): | if passwd.endswith("'"): | ||||
| passwd = passwd[1:-1].replace("''", "'") | passwd = passwd[1:-1].replace("''", "'") | ||||
| else: | else: | ||||
| raise error.Abort(_('malformed password string')) | raise error.Abort(_('malformed password string')) | ||||
| return (user, passwd) | return user, passwd | ||||
| except (OSError, IOError): | except (OSError, IOError): | ||||
| raise error.Abort(_('factotum not responding')) | raise error.Abort(_('factotum not responding')) | ||||
| finally: | finally: | ||||
| os.close(fd) | os.close(fd) | ||||
| getkey(self, params) | getkey(self, params) | ||||
| def monkeypatch_method(cls): | def monkeypatch_method(cls): | ||||
| def decorator(func): | def decorator(func): | ||||
| setattr(cls, func.__name__, func) | setattr(cls, func.__name__, func) | ||||
| return func | return func | ||||
| return decorator | return decorator | ||||
| @monkeypatch_method(passwordmgr) | @monkeypatch_method(passwordmgr) | ||||
| def find_user_password(self, realm, authuri): | def find_user_password(self, realm, authuri): | ||||
| user, passwd = self.passwddb.find_user_password(realm, authuri) | user, passwd = self.passwddb.find_user_password(realm, authuri) | ||||
| if user and passwd: | if user and passwd: | ||||
| self._writedebug(user, passwd) | self._writedebug(user, passwd) | ||||
| return (user, passwd) | return user, passwd | ||||
| prefix = '' | prefix = '' | ||||
| res = httpconnection.readauthforuri(self.ui, authuri, user) | res = httpconnection.readauthforuri(self.ui, authuri, user) | ||||
| if res: | if res: | ||||
| _, auth = res | _, auth = res | ||||
| prefix = auth.get('prefix') | prefix = auth.get('prefix') | ||||
| user, passwd = auth.get('username'), auth.get('password') | user, passwd = auth.get('username'), auth.get('password') | ||||
| if not user or not passwd: | if not user or not passwd: | ||||
| if not prefix: | if not prefix: | ||||
| prefix = realm.split(' ')[0].lower() | prefix = realm.split(' ')[0].lower() | ||||
| params = 'service=%s prefix=%s' % (_service, prefix) | params = 'service=%s prefix=%s' % (_service, prefix) | ||||
| if user: | if user: | ||||
| params = '%s user=%s' % (params, user) | params = '%s user=%s' % (params, user) | ||||
| user, passwd = auth_getuserpasswd(self, auth_getkey, params) | user, passwd = auth_getuserpasswd(self, auth_getkey, params) | ||||
| self.add_password(realm, authuri, user, passwd) | self.add_password(realm, authuri, user, passwd) | ||||
| self._writedebug(user, passwd) | self._writedebug(user, passwd) | ||||
| return (user, passwd) | return user, passwd | ||||
| def uisetup(ui): | def uisetup(ui): | ||||
| global _executable | global _executable | ||||
| _executable = ui.config('factotum', 'executable') | _executable = ui.config('factotum', 'executable') | ||||
| global _mountpoint | global _mountpoint | ||||
| _mountpoint = ui.config('factotum', 'mountpoint') | _mountpoint = ui.config('factotum', 'mountpoint') | ||||
| global _service | global _service | ||||
| _service = ui.config('factotum', 'service') | _service = ui.config('factotum', 'service') | ||||
| # leave the attribute unspecified. | # leave the attribute unspecified. | ||||
| testedwith = 'ships-with-hg-core' | testedwith = 'ships-with-hg-core' | ||||
| # hg commands that do not act on keywords | # hg commands that do not act on keywords | ||||
| nokwcommands = ('add addremove annotate bundle export grep incoming init log' | nokwcommands = ('add addremove annotate bundle export grep incoming init log' | ||||
| ' outgoing push tip verify convert email glog') | ' outgoing push tip verify convert email glog') | ||||
| # webcommands that do not act on keywords | # webcommands that do not act on keywords | ||||
| nokwwebcommands = ('annotate changeset rev filediff diff comparison') | nokwwebcommands = 'annotate changeset rev filediff diff comparison' | ||||
| # hg commands that trigger expansion only when writing to working dir, | # hg commands that trigger expansion only when writing to working dir, | ||||
| # not when reading filelog, and unexpand when reading from working dir | # not when reading filelog, and unexpand when reading from working dir | ||||
| restricted = ('merge kwexpand kwshrink record qrecord resolve transplant' | restricted = ('merge kwexpand kwshrink record qrecord resolve transplant' | ||||
| ' unshelve rebase graft backout histedit fetch') | ' unshelve rebase graft backout histedit fetch') | ||||
| # names of extensions using dorecord | # names of extensions using dorecord | ||||
| recordextensions = 'record' | recordextensions = 'record' | ||||
| continue | continue | ||||
| if self._gethash(filename, hash): | if self._gethash(filename, hash): | ||||
| success.append((filename, hash)) | success.append((filename, hash)) | ||||
| else: | else: | ||||
| missing.append(filename) | missing.append(filename) | ||||
| ui.progress(_('getting largefiles'), None) | ui.progress(_('getting largefiles'), None) | ||||
| return (success, missing) | return success, missing | ||||
| def _gethash(self, filename, hash): | def _gethash(self, filename, hash): | ||||
| """Get file with the provided hash and store it in the local repo's | """Get file with the provided hash and store it in the local repo's | ||||
| store and in the usercache. | store and in the usercache. | ||||
| filename is for informational messages only. | filename is for informational messages only. | ||||
| """ | """ | ||||
| util.makedirs(lfutil.storepath(self.repo, '')) | util.makedirs(lfutil.storepath(self.repo, '')) | ||||
| storefilename = lfutil.storepath(self.repo, hash) | storefilename = lfutil.storepath(self.repo, hash) | ||||
| if not lfutil.findfile(repo, expectedhash): | if not lfutil.findfile(repo, expectedhash): | ||||
| toget.append((lfile, expectedhash)) | toget.append((lfile, expectedhash)) | ||||
| if toget: | if toget: | ||||
| store = storefactory.openstore(repo) | store = storefactory.openstore(repo) | ||||
| ret = store.get(toget) | ret = store.get(toget) | ||||
| return ret | return ret | ||||
| return ([], []) | return [], [] | ||||
| def downloadlfiles(ui, repo, rev=None): | def downloadlfiles(ui, repo, rev=None): | ||||
| match = scmutil.match(repo[None], [repo.wjoin(lfutil.shortname)], {}) | match = scmutil.match(repo[None], [repo.wjoin(lfutil.shortname)], {}) | ||||
| def prepare(ctx, fns): | def prepare(ctx, fns): | ||||
| pass | pass | ||||
| totalsuccess = 0 | totalsuccess = 0 | ||||
| totalmissing = 0 | totalmissing = 0 | ||||
| if rev != []: # walkchangerevs on empty list would return all revs | if rev != []: # walkchangerevs on empty list would return all revs | ||||
| The return value is a tuple of (path, exists(path)). | The return value is a tuple of (path, exists(path)). | ||||
| ''' | ''' | ||||
| # For shared repos, the primary store is in the share source. But for | # For shared repos, the primary store is in the share source. But for | ||||
| # backward compatibility, force a lookup in the local store if it wasn't | # backward compatibility, force a lookup in the local store if it wasn't | ||||
| # found in the share source. | # found in the share source. | ||||
| path = storepath(repo, hash, False) | path = storepath(repo, hash, False) | ||||
| if instore(repo, hash): | if instore(repo, hash): | ||||
| return (path, True) | return path, True | ||||
| elif repo.shared() and instore(repo, hash, True): | elif repo.shared() and instore(repo, hash, True): | ||||
| return storepath(repo, hash, True), True | return storepath(repo, hash, True), True | ||||
| return (path, False) | return path, False | ||||
| def copyfromcache(repo, hash, filename): | def copyfromcache(repo, hash, filename): | ||||
| '''Copy the specified largefile from the repo or system cache to | '''Copy the specified largefile from the repo or system cache to | ||||
| filename in the repository. Return true on success or false if the | filename in the repository. Return true on success or false if the | ||||
| file was not found in either cache (which should not happened: | file was not found in either cache (which should not happened: | ||||
| this is meant to be called only after ensuring that the needed | this is meant to be called only after ensuring that the needed | ||||
| largefile exists in the cache).''' | largefile exists in the cache).''' | ||||
| wvfs = repo.wvfs | wvfs = repo.wvfs | ||||
| with repo.wlock(): | with repo.wlock(): | ||||
| lfdirstate = lfutil.openlfdirstate(ui, repo) | lfdirstate = lfutil.openlfdirstate(ui, repo) | ||||
| s = lfutil.lfdirstatestatus(lfdirstate, repo) | s = lfutil.lfdirstatestatus(lfdirstate, repo) | ||||
| lfdirstate.write() | lfdirstate.write() | ||||
| for lfile in s.modified: | for lfile in s.modified: | ||||
| lfutil.updatestandin(repo, lfile, lfutil.standin(lfile)) | lfutil.updatestandin(repo, lfile, lfutil.standin(lfile)) | ||||
| for lfile in s.deleted: | for lfile in s.deleted: | ||||
| fstandin = lfutil.standin(lfile) | fstandin = lfutil.standin(lfile) | ||||
| if (repo.wvfs.exists(fstandin)): | if repo.wvfs.exists(fstandin): | ||||
| repo.wvfs.unlink(fstandin) | repo.wvfs.unlink(fstandin) | ||||
| oldstandins = lfutil.getstandinsstate(repo) | oldstandins = lfutil.getstandinsstate(repo) | ||||
| def overridematch(mctx, pats=(), opts=None, globbed=False, | def overridematch(mctx, pats=(), opts=None, globbed=False, | ||||
| default='relpath', badfn=None): | default='relpath', badfn=None): | ||||
| if opts is None: | if opts is None: | ||||
| opts = {} | opts = {} | ||||
| toupload = {} | toupload = {} | ||||
| def addfunc(fn, lfhash): | def addfunc(fn, lfhash): | ||||
| if fn not in toupload: | if fn not in toupload: | ||||
| toupload[fn] = [] | toupload[fn] = [] | ||||
| toupload[fn].append(lfhash) | toupload[fn].append(lfhash) | ||||
| lfhashes.add(lfhash) | lfhashes.add(lfhash) | ||||
| def showhashes(fn): | def showhashes(fn): | ||||
| for lfhash in sorted(toupload[fn]): | for lfhash in sorted(toupload[fn]): | ||||
| ui.debug(' %s\n' % (lfhash)) | ui.debug(' %s\n' % lfhash) | ||||
| else: | else: | ||||
| toupload = set() | toupload = set() | ||||
| def addfunc(fn, lfhash): | def addfunc(fn, lfhash): | ||||
| toupload.add(fn) | toupload.add(fn) | ||||
| lfhashes.add(lfhash) | lfhashes.add(lfhash) | ||||
| def showhashes(fn): | def showhashes(fn): | ||||
| pass | pass | ||||
| _getoutgoings(repo, other, missing, addfunc) | _getoutgoings(repo, other, missing, addfunc) | ||||
| if not toupload: | if not toupload: | ||||
| ui.status(_('largefiles: no files to upload\n')) | ui.status(_('largefiles: no files to upload\n')) | ||||
| else: | else: | ||||
| ui.status(_('largefiles to upload (%d entities):\n') | ui.status(_('largefiles to upload (%d entities):\n') | ||||
| % (len(lfhashes))) | % (len(lfhashes))) | ||||
| for file in sorted(toupload): | for file in sorted(toupload): | ||||
| ui.status(lfutil.splitstandin(file) + '\n') | ui.status(lfutil.splitstandin(file) + '\n') | ||||
| showhashes(file) | showhashes(file) | ||||
| ui.status('\n') | ui.status('\n') | ||||
| def summaryremotehook(ui, repo, opts, changes): | def summaryremotehook(ui, repo, opts, changes): | ||||
| largeopt = opts.get('large', False) | largeopt = opts.get('large', False) | ||||
| if changes is None: | if changes is None: | ||||
| if largeopt: | if largeopt: | ||||
| return (False, True) # only outgoing check is needed | return False, True # only outgoing check is needed | ||||
| else: | else: | ||||
| return (False, False) | return False, False | ||||
| elif largeopt: | elif largeopt: | ||||
| url, branch, peer, outgoing = changes[1] | url, branch, peer, outgoing = changes[1] | ||||
| if peer is None: | if peer is None: | ||||
| # i18n: column positioning for "hg summary" | # i18n: column positioning for "hg summary" | ||||
| ui.status(_('largefiles: (no remote repo)\n')) | ui.status(_('largefiles: (no remote repo)\n')) | ||||
| return | return | ||||
| toupload = set() | toupload = set() | ||||
| changes, stat, fp) | changes, stat, fp) | ||||
| def mergeone(self, repo, mergeq, head, patch, rev, diffopts): | def mergeone(self, repo, mergeq, head, patch, rev, diffopts): | ||||
| # first try just applying the patch | # first try just applying the patch | ||||
| (err, n) = self.apply(repo, [patch], update_status=False, | (err, n) = self.apply(repo, [patch], update_status=False, | ||||
| strict=True, merge=rev) | strict=True, merge=rev) | ||||
| if err == 0: | if err == 0: | ||||
| return (err, n) | return err, n | ||||
| if n is None: | if n is None: | ||||
| raise error.Abort(_("apply failed for patch %s") % patch) | raise error.Abort(_("apply failed for patch %s") % patch) | ||||
| self.ui.warn(_("patch didn't work out, merging %s\n") % patch) | self.ui.warn(_("patch didn't work out, merging %s\n") % patch) | ||||
| # apply failed, strip away that rev and merge. | # apply failed, strip away that rev and merge. | ||||
| hg.clean(repo, head) | hg.clean(repo, head) | ||||
| diffopts = self.patchopts(diffopts, patch) | diffopts = self.patchopts(diffopts, patch) | ||||
| patchf = self.opener(patch, "w") | patchf = self.opener(patch, "w") | ||||
| comments = str(ph) | comments = str(ph) | ||||
| if comments: | if comments: | ||||
| patchf.write(comments) | patchf.write(comments) | ||||
| self.printdiff(repo, diffopts, head, n, fp=patchf) | self.printdiff(repo, diffopts, head, n, fp=patchf) | ||||
| patchf.close() | patchf.close() | ||||
| self.removeundo(repo) | self.removeundo(repo) | ||||
| return (0, n) | return 0, n | ||||
| def qparents(self, repo, rev=None): | def qparents(self, repo, rev=None): | ||||
| """return the mq handled parent or p1 | """return the mq handled parent or p1 | ||||
| In some case where mq get himself in being the parent of a merge the | In some case where mq get himself in being the parent of a merge the | ||||
| appropriate parent may be p2. | appropriate parent may be p2. | ||||
| (eg: an in progress merge started with mq disabled) | (eg: an in progress merge started with mq disabled) | ||||
| self.applieddirty = True | self.applieddirty = True | ||||
| head = self.qparents(repo) | head = self.qparents(repo) | ||||
| for patch in series: | for patch in series: | ||||
| patch = mergeq.lookup(patch, strict=True) | patch = mergeq.lookup(patch, strict=True) | ||||
| if not patch: | if not patch: | ||||
| self.ui.warn(_("patch %s does not exist\n") % patch) | self.ui.warn(_("patch %s does not exist\n") % patch) | ||||
| return (1, None) | return 1, None | ||||
| pushable, reason = self.pushable(patch) | pushable, reason = self.pushable(patch) | ||||
| if not pushable: | if not pushable: | ||||
| self.explainpushable(patch, all_patches=True) | self.explainpushable(patch, all_patches=True) | ||||
| continue | continue | ||||
| info = mergeq.isapplied(patch) | info = mergeq.isapplied(patch) | ||||
| if not info: | if not info: | ||||
| self.ui.warn(_("patch %s is not applied\n") % patch) | self.ui.warn(_("patch %s is not applied\n") % patch) | ||||
| return (1, None) | return 1, None | ||||
| rev = info[1] | rev = info[1] | ||||
| err, head = self.mergeone(repo, mergeq, head, patch, rev, diffopts) | err, head = self.mergeone(repo, mergeq, head, patch, rev, diffopts) | ||||
| if head: | if head: | ||||
| self.applied.append(statusentry(head, patch)) | self.applied.append(statusentry(head, patch)) | ||||
| self.applieddirty = True | self.applieddirty = True | ||||
| if err: | if err: | ||||
| return (err, head) | return err, head | ||||
| self.savedirty() | self.savedirty() | ||||
| return (0, head) | return 0, head | ||||
| def patch(self, repo, patchfile): | def patch(self, repo, patchfile): | ||||
| '''Apply patchfile to the working directory. | '''Apply patchfile to the working directory. | ||||
| patchfile: name of patch file''' | patchfile: name of patch file''' | ||||
| files = set() | files = set() | ||||
| try: | try: | ||||
| fuzz = patchmod.patch(self.ui, repo, patchfile, strip=1, | fuzz = patchmod.patch(self.ui, repo, patchfile, strip=1, | ||||
| files=files, eolmode=None) | files=files, eolmode=None) | ||||
| return (True, list(files), fuzz) | return True, list(files), fuzz | ||||
| except Exception as inst: | except Exception as inst: | ||||
| self.ui.note(str(inst) + '\n') | self.ui.note(str(inst) + '\n') | ||||
| if not self.ui.verbose: | if not self.ui.verbose: | ||||
| self.ui.warn(_("patch failed, unable to continue (try -v)\n")) | self.ui.warn(_("patch failed, unable to continue (try -v)\n")) | ||||
| self.ui.traceback() | self.ui.traceback() | ||||
| return (False, list(files), False) | return False, list(files), False | ||||
| def apply(self, repo, series, list=False, update_status=True, | def apply(self, repo, series, list=False, update_status=True, | ||||
| strict=False, patchdir=None, merge=None, all_files=None, | strict=False, patchdir=None, merge=None, all_files=None, | ||||
| tobackup=None, keepchanges=False): | tobackup=None, keepchanges=False): | ||||
| wlock = lock = tr = None | wlock = lock = tr = None | ||||
| try: | try: | ||||
| wlock = repo.wlock() | wlock = repo.wlock() | ||||
| lock = repo.lock() | lock = repo.lock() | ||||
| "directory\n")) | "directory\n")) | ||||
| err = 2 | err = 2 | ||||
| break | break | ||||
| if fuzz and strict: | if fuzz and strict: | ||||
| self.ui.warn(_("fuzz found when applying patch, stopping\n")) | self.ui.warn(_("fuzz found when applying patch, stopping\n")) | ||||
| err = 3 | err = 3 | ||||
| break | break | ||||
| return (err, n) | return err, n | ||||
| def _cleanup(self, patches, numrevs, keep=False): | def _cleanup(self, patches, numrevs, keep=False): | ||||
| if not keep: | if not keep: | ||||
| r = self.qrepo() | r = self.qrepo() | ||||
| if r: | if r: | ||||
| r[None].forget(patches) | r[None].forget(patches) | ||||
| for p in patches: | for p in patches: | ||||
| try: | try: | ||||
| self.ui.warn(_('error unlinking %s\n') % patchpath) | self.ui.warn(_('error unlinking %s\n') % patchpath) | ||||
| raise | raise | ||||
| self.removeundo(repo) | self.removeundo(repo) | ||||
| def isapplied(self, patch): | def isapplied(self, patch): | ||||
| """returns (index, rev, patch)""" | """returns (index, rev, patch)""" | ||||
| for i, a in enumerate(self.applied): | for i, a in enumerate(self.applied): | ||||
| if a.name == patch: | if a.name == patch: | ||||
| return (i, a.node, a.name) | return i, a.node, a.name | ||||
| return None | return None | ||||
| # if the exact patch name does not exist, we try a few | # if the exact patch name does not exist, we try a few | ||||
| # variations. If strict is passed, we try only #1 | # variations. If strict is passed, we try only #1 | ||||
| # | # | ||||
| # 1) a number (as string) to indicate an offset in the series file | # 1) a number (as string) to indicate an offset in the series file | ||||
| # 2) a unique substring of the patch name was given | # 2) a unique substring of the patch name was given | ||||
| # 3) patchname[-+]num to indicate an offset in the series file | # 3) patchname[-+]num to indicate an offset in the series file | ||||
| for f in files: | for f in files: | ||||
| fl = os.path.join(d, f) | fl = os.path.join(d, f) | ||||
| if (fl not in self.series and | if (fl not in self.series and | ||||
| fl not in (self.statuspath, self.seriespath, | fl not in (self.statuspath, self.seriespath, | ||||
| self.guardspath) | self.guardspath) | ||||
| and not fl.startswith('.')): | and not fl.startswith('.')): | ||||
| msng_list.append(fl) | msng_list.append(fl) | ||||
| for x in sorted(msng_list): | for x in sorted(msng_list): | ||||
| pfx = self.ui.verbose and ('D ') or '' | pfx = self.ui.verbose and 'D ' or '' | ||||
| displayname(pfx, x, 'missing') | displayname(pfx, x, 'missing') | ||||
| def issaveline(self, l): | def issaveline(self, l): | ||||
| if l.name == '.hg.patches.save.line': | if l.name == '.hg.patches.save.line': | ||||
| return True | return True | ||||
| def qrepo(self, create=False): | def qrepo(self, create=False): | ||||
| ui = self.baseui.copy() | ui = self.baseui.copy() | ||||
| for f in names: | for f in names: | ||||
| m = namere.match(f) | m = namere.match(f) | ||||
| if m: | if m: | ||||
| index = int(m.group(1)) | index = int(m.group(1)) | ||||
| if maxindex is None or index > maxindex: | if maxindex is None or index > maxindex: | ||||
| maxindex = index | maxindex = index | ||||
| maxname = f | maxname = f | ||||
| if maxname: | if maxname: | ||||
| return (os.path.join(directory, maxname), maxindex) | return os.path.join(directory, maxname), maxindex | ||||
| return (None, None) | return None, None | ||||
| def savename(path): | def savename(path): | ||||
| (last, index) = lastsavename(path) | (last, index) = lastsavename(path) | ||||
| if last is None: | if last is None: | ||||
| index = 0 | index = 0 | ||||
| newpath = path + ".%d" % (index + 1) | newpath = path + ".%d" % (index + 1) | ||||
| return newpath | return newpath | ||||
| body = '\n' + diffstat | body = '\n' + diffstat | ||||
| else: | else: | ||||
| diffstat = None | diffstat = None | ||||
| body = _getdescription(repo, body, sender, **opts) | body = _getdescription(repo, body, sender, **opts) | ||||
| msg = mail.mimeencode(ui, body, _charsets, opts.get('test')) | msg = mail.mimeencode(ui, body, _charsets, opts.get('test')) | ||||
| msg['Subject'] = mail.headencode(ui, subj, _charsets, | msg['Subject'] = mail.headencode(ui, subj, _charsets, | ||||
| opts.get('test')) | opts.get('test')) | ||||
| return (msg, subj, diffstat) | return msg, subj, diffstat | ||||
| def _getpatchmsgs(repo, sender, revs, patchnames=None, **opts): | def _getpatchmsgs(repo, sender, revs, patchnames=None, **opts): | ||||
| """return a list of emails from a list of patches | """return a list of emails from a list of patches | ||||
| This involves introduction message creation if necessary. | This involves introduction message creation if necessary. | ||||
| This function returns a list of "email" tuples (subject, content, None). | This function returns a list of "email" tuples (subject, content, None). | ||||
| """ | """ | ||||
| showview = showcmdfunc() | showview = showcmdfunc() | ||||
| @command('show', [ | @command('show', [ | ||||
| # TODO: Switch this template flag to use cmdutil.formatteropts if | # TODO: Switch this template flag to use cmdutil.formatteropts if | ||||
| # 'hg show' becomes stable before --template/-T is stable. For now, | # 'hg show' becomes stable before --template/-T is stable. For now, | ||||
| # we are putting it here without the '(EXPERIMENTAL)' flag because it | # we are putting it here without the '(EXPERIMENTAL)' flag because it | ||||
| # is an important part of the 'hg show' user experience and the entire | # is an important part of the 'hg show' user experience and the entire | ||||
| # 'hg show' experience is experimental. | # 'hg show' experience is experimental. | ||||
| ('T', 'template', '', ('display with template'), _('TEMPLATE')), | ('T', 'template', '', 'display with template', _('TEMPLATE')), | ||||
| ], _('VIEW')) | ], _('VIEW')) | ||||
| def show(ui, repo, view=None, template=None): | def show(ui, repo, view=None, template=None): | ||||
| """show various repository information | """show various repository information | ||||
| A requested view of repository data is displayed. | A requested view of repository data is displayed. | ||||
| If no view is requested, the list of available views is shown and the | If no view is requested, the list of available views is shown and the | ||||
| command aborts. | command aborts. | ||||
| 'HGREVISION': nodemod.hex(node), | 'HGREVISION': nodemod.hex(node), | ||||
| }, | }, | ||||
| onerr=error.Abort, errprefix=_('filter failed'), | onerr=error.Abort, errprefix=_('filter failed'), | ||||
| blockedtag='transplant_filter') | blockedtag='transplant_filter') | ||||
| user, date, msg = self.parselog(file(headerfile))[1:4] | user, date, msg = self.parselog(file(headerfile))[1:4] | ||||
| finally: | finally: | ||||
| os.unlink(headerfile) | os.unlink(headerfile) | ||||
| return (user, date, msg) | return user, date, msg | ||||
| def applyone(self, repo, node, cl, patchfile, merge=False, log=False, | def applyone(self, repo, node, cl, patchfile, merge=False, log=False, | ||||
| filter=None): | filter=None): | ||||
| '''apply the patch in patchfile to the repository as a transplant''' | '''apply the patch in patchfile to the repository as a transplant''' | ||||
| (manifest, user, (time, timezone), files, message) = cl[:5] | (manifest, user, (time, timezone), files, message) = cl[:5] | ||||
| date = "%d %d" % (time, timezone) | date = "%d %d" % (time, timezone) | ||||
| extra = {'transplant_source': node} | extra = {'transplant_source': node} | ||||
| if filter: | if filter: | ||||
| merges = [] | merges = [] | ||||
| cur = nodes | cur = nodes | ||||
| for line in self.opener.read('series').splitlines(): | for line in self.opener.read('series').splitlines(): | ||||
| if line.startswith('# Merges'): | if line.startswith('# Merges'): | ||||
| cur = merges | cur = merges | ||||
| continue | continue | ||||
| cur.append(revlog.bin(line)) | cur.append(revlog.bin(line)) | ||||
| return (nodes, merges) | return nodes, merges | ||||
| def saveseries(self, revmap, merges): | def saveseries(self, revmap, merges): | ||||
| if not revmap: | if not revmap: | ||||
| return | return | ||||
| if not os.path.isdir(self.path): | if not os.path.isdir(self.path): | ||||
| os.mkdir(self.path) | os.mkdir(self.path) | ||||
| series = self.opener('series', 'w') | series = self.opener('series', 'w') | ||||
| node = revlog.bin(line[10:]) | node = revlog.bin(line[10:]) | ||||
| elif line.startswith('# Parent '): | elif line.startswith('# Parent '): | ||||
| parents.append(revlog.bin(line[9:])) | parents.append(revlog.bin(line[9:])) | ||||
| elif not line.startswith('# '): | elif not line.startswith('# '): | ||||
| inmsg = True | inmsg = True | ||||
| message.append(line) | message.append(line) | ||||
| if None in (user, date): | if None in (user, date): | ||||
| raise error.Abort(_("filter corrupted changeset (no user or date)")) | raise error.Abort(_("filter corrupted changeset (no user or date)")) | ||||
| return (node, user, date, '\n'.join(message), parents) | return node, user, date, '\n'.join(message), parents | ||||
| def log(self, user, date, message, p1, p2, merge=False): | def log(self, user, date, message, p1, p2, merge=False): | ||||
| '''journal changelog metadata for later recover''' | '''journal changelog metadata for later recover''' | ||||
| if not os.path.isdir(self.path): | if not os.path.isdir(self.path): | ||||
| os.mkdir(self.path) | os.mkdir(self.path) | ||||
| fp = self.opener('journal', 'w') | fp = self.opener('journal', 'w') | ||||
| fp.write('# User %s\n' % user) | fp.write('# User %s\n' % user) | ||||
| merges.append(node) | merges.append(node) | ||||
| elif action == 'c': | elif action == 'c': | ||||
| break | break | ||||
| elif action == 'q': | elif action == 'q': | ||||
| transplants = () | transplants = () | ||||
| merges = () | merges = () | ||||
| break | break | ||||
| displayer.close() | displayer.close() | ||||
| return (transplants, merges) | return transplants, merges | ||||
| @command('transplant', | @command('transplant', | ||||
| [('s', 'source', '', _('transplant changesets from REPO'), _('REPO')), | [('s', 'source', '', _('transplant changesets from REPO'), _('REPO')), | ||||
| ('b', 'branch', [], _('use this source changeset as head'), _('REV')), | ('b', 'branch', [], _('use this source changeset as head'), _('REV')), | ||||
| ('a', 'all', None, _('pull all changesets up to the --branch revisions')), | ('a', 'all', None, _('pull all changesets up to the --branch revisions')), | ||||
| ('p', 'prune', [], _('skip over REV'), _('REV')), | ('p', 'prune', [], _('skip over REV'), _('REV')), | ||||
| ('m', 'merge', [], _('merge at REV'), _('REV')), | ('m', 'merge', [], _('merge at REV'), _('REV')), | ||||
| ('', 'parent', '', | ('', 'parent', '', | ||||
| src = oldctx[f].renamed() | src = oldctx[f].renamed() | ||||
| if src: | if src: | ||||
| oldcopies[f] = src[0] | oldcopies[f] = src[0] | ||||
| oldcopies.update(copies) | oldcopies.update(copies) | ||||
| copies = dict((dst, oldcopies.get(src, src)) | copies = dict((dst, oldcopies.get(src, src)) | ||||
| for dst, src in oldcopies.iteritems()) | for dst, src in oldcopies.iteritems()) | ||||
| # Adjust the dirstate copies | # Adjust the dirstate copies | ||||
| for dst, src in copies.iteritems(): | for dst, src in copies.iteritems(): | ||||
| if (src not in ctx or dst in ctx or ds[dst] != 'a'): | if src not in ctx or dst in ctx or ds[dst] != 'a': | ||||
| src = None | src = None | ||||
| ds.copy(src, dst) | ds.copy(src, dst) | ||||
| @command('uncommit', | @command('uncommit', | ||||
| [('', 'keep', False, _('allow an empty commit after uncommiting')), | [('', 'keep', False, _('allow an empty commit after uncommiting')), | ||||
| ] + commands.walkopts, | ] + commands.walkopts, | ||||
| _('[OPTION]... [FILE]...')) | _('[OPTION]... [FILE]...')) | ||||
| def uncommit(ui, repo, *pats, **opts): | def uncommit(ui, repo, *pats, **opts): | ||||
| return func(*args, **kwds) | return func(*args, **kwds) | ||||
| try: | try: | ||||
| # convert string arguments, call func, then convert back the | # convert string arguments, call func, then convert back the | ||||
| # return value. | # return value. | ||||
| return enc(func(*dec(args), **dec(kwds))) | return enc(func(*dec(args), **dec(kwds))) | ||||
| except UnicodeError: | except UnicodeError: | ||||
| raise error.Abort(_("[win32mbcs] filename conversion failed with" | raise error.Abort(_("[win32mbcs] filename conversion failed with" | ||||
| " %s encoding\n") % (_encoding)) | " %s encoding\n") % _encoding) | ||||
| def wrapper(func, args, kwds): | def wrapper(func, args, kwds): | ||||
| return basewrapper(func, unicode, encode, decode, args, kwds) | return basewrapper(func, unicode, encode, decode, args, kwds) | ||||
| def reversewrapper(func, args, kwds): | def reversewrapper(func, args, kwds): | ||||
| return basewrapper(func, str, decode, encode, args, kwds) | return basewrapper(func, str, decode, encode, args, kwds) | ||||
| def cleanup(): | def cleanup(): | ||||
| if bundlerepo: | if bundlerepo: | ||||
| bundlerepo.close() | bundlerepo.close() | ||||
| if bundle: | if bundle: | ||||
| os.unlink(bundle) | os.unlink(bundle) | ||||
| other.close() | other.close() | ||||
| return (localrepo, csets, cleanup) | return localrepo, csets, cleanup | ||||
| def tell(self): | def tell(self): | ||||
| """Return the position within the range. | """Return the position within the range. | ||||
| This is different from fo.seek in that position 0 is the | This is different from fo.seek in that position 0 is the | ||||
| first byte position of the range tuple. For example, if | first byte position of the range tuple. For example, if | ||||
| this object was created with a range tuple of (500,899), | this object was created with a range tuple of (500,899), | ||||
| tell() will return 0 when at byte position 500 of the file. | tell() will return 0 when at byte position 500 of the file. | ||||
| """ | """ | ||||
| return (self.realpos - self.firstbyte) | return self.realpos - self.firstbyte | ||||
| def seek(self, offset, whence=0): | def seek(self, offset, whence=0): | ||||
| """Seek within the byte range. | """Seek within the byte range. | ||||
| Positioning is identical to that described under tell(). | Positioning is identical to that described under tell(). | ||||
| """ | """ | ||||
| assert whence in (0, 1, 2) | assert whence in (0, 1, 2) | ||||
| if whence == 0: # absolute seek | if whence == 0: # absolute seek | ||||
| realoffset = self.firstbyte + offset | realoffset = self.firstbyte + offset | ||||
| return rslt | return rslt | ||||
| def _calc_read_size(self, size): | def _calc_read_size(self, size): | ||||
| """Handles calculating the amount of data to read based on | """Handles calculating the amount of data to read based on | ||||
| the range. | the range. | ||||
| """ | """ | ||||
| if self.lastbyte: | if self.lastbyte: | ||||
| if size > -1: | if size > -1: | ||||
| if ((self.realpos + size) >= self.lastbyte): | if (self.realpos + size) >= self.lastbyte: | ||||
| size = (self.lastbyte - self.realpos) | size = (self.lastbyte - self.realpos) | ||||
| else: | else: | ||||
| size = (self.lastbyte - self.realpos) | size = (self.lastbyte - self.realpos) | ||||
| return size | return size | ||||
| def _do_seek(self, offset): | def _do_seek(self, offset): | ||||
| """Seek based on whether wrapped object supports seek(). | """Seek based on whether wrapped object supports seek(). | ||||
| offset is relative to the current position (self.realpos). | offset is relative to the current position (self.realpos). | ||||
| try: | try: | ||||
| cmd = 'RETR ' + file | cmd = 'RETR ' + file | ||||
| conn = self.ftp.ntransfercmd(cmd, rest) | conn = self.ftp.ntransfercmd(cmd, rest) | ||||
| except ftplib.error_perm as reason: | except ftplib.error_perm as reason: | ||||
| if str(reason).startswith('501'): | if str(reason).startswith('501'): | ||||
| # workaround for REST not supported error | # workaround for REST not supported error | ||||
| fp, retrlen = self.retrfile(file, type) | fp, retrlen = self.retrfile(file, type) | ||||
| fp = RangeableFileObject(fp, (rest,'')) | fp = RangeableFileObject(fp, (rest,'')) | ||||
| return (fp, retrlen) | return fp, retrlen | ||||
| elif not str(reason).startswith('550'): | elif not str(reason).startswith('550'): | ||||
| raise IOError('ftp error', reason) | raise IOError('ftp error', reason) | ||||
| if not conn: | if not conn: | ||||
| # Set transfer mode to ASCII! | # Set transfer mode to ASCII! | ||||
| self.ftp.voidcmd('TYPE A') | self.ftp.voidcmd('TYPE A') | ||||
| # Try a directory listing | # Try a directory listing | ||||
| if file: | if file: | ||||
| cmd = 'LIST ' + file | cmd = 'LIST ' + file | ||||
| elif lb != '': | elif lb != '': | ||||
| lb = int(lb) | lb = int(lb) | ||||
| # check if range is over the entire file | # check if range is over the entire file | ||||
| if (fb, lb) == (0, ''): | if (fb, lb) == (0, ''): | ||||
| return None | return None | ||||
| # check that the range is valid | # check that the range is valid | ||||
| if lb < fb: | if lb < fb: | ||||
| raise RangeError('Invalid byte range: %s-%s' % (fb, lb)) | raise RangeError('Invalid byte range: %s-%s' % (fb, lb)) | ||||
| return (fb, lb) | return fb, lb | ||||
| def deltachunk(self, prevnode): | def deltachunk(self, prevnode): | ||||
| l = self._chunklength() | l = self._chunklength() | ||||
| if not l: | if not l: | ||||
| return {} | return {} | ||||
| headerdata = readexactly(self._stream, self.deltaheadersize) | headerdata = readexactly(self._stream, self.deltaheadersize) | ||||
| header = struct.unpack(self.deltaheader, headerdata) | header = struct.unpack(self.deltaheader, headerdata) | ||||
| delta = readexactly(self._stream, l - self.deltaheadersize) | delta = readexactly(self._stream, l - self.deltaheadersize) | ||||
| node, p1, p2, deltabase, cs, flags = self._deltaheader(header, prevnode) | node, p1, p2, deltabase, cs, flags = self._deltaheader(header, prevnode) | ||||
| return (node, p1, p2, cs, deltabase, delta, flags) | return node, p1, p2, cs, deltabase, delta, flags | ||||
| def getchunks(self): | def getchunks(self): | ||||
| """returns all the chunks contains in the bundle | """returns all the chunks contains in the bundle | ||||
| Used when you need to forward the binary stream to a file or another | Used when you need to forward the binary stream to a file or another | ||||
| network API. To do so, it parse the changegroup data, otherwise it will | network API. To do so, it parse the changegroup data, otherwise it will | ||||
| block in case of sshrepo because it don't know the end of the stream. | block in case of sshrepo because it don't know the end of the stream. | ||||
| """ | """ | ||||
| mtimehash is not included in confighash because we only know the paths of | mtimehash is not included in confighash because we only know the paths of | ||||
| extensions after importing them (there is imp.find_module but that faces | extensions after importing them (there is imp.find_module but that faces | ||||
| race conditions). We need to calculate confighash without importing. | race conditions). We need to calculate confighash without importing. | ||||
| """ | """ | ||||
| def trystat(path): | def trystat(path): | ||||
| try: | try: | ||||
| st = os.stat(path) | st = os.stat(path) | ||||
| return (st.st_mtime, st.st_size) | return st.st_mtime, st.st_size | ||||
| except OSError: | except OSError: | ||||
| # could be ENOENT, EPERM etc. not fatal in any case | # could be ENOENT, EPERM etc. not fatal in any case | ||||
| pass | pass | ||||
| return _hashlist(map(trystat, paths))[:12] | return _hashlist(map(trystat, paths))[:12] | ||||
| class hashstate(object): | class hashstate(object): | ||||
| """a structure storing confighash, mtimehash, paths used for mtimehash""" | """a structure storing confighash, mtimehash, paths used for mtimehash""" | ||||
| def __init__(self, confighash, mtimehash, mtimepaths): | def __init__(self, confighash, mtimehash, mtimepaths): | ||||
| newui.setconfig(section, name, value, source) | newui.setconfig(section, name, value, source) | ||||
| # load wd and repo config, copied from dispatch.py | # load wd and repo config, copied from dispatch.py | ||||
| cwds = dispatch._earlygetopt(['--cwd'], args) | cwds = dispatch._earlygetopt(['--cwd'], args) | ||||
| cwd = cwds and os.path.realpath(cwds[-1]) or None | cwd = cwds and os.path.realpath(cwds[-1]) or None | ||||
| rpath = dispatch._earlygetopt(["-R", "--repository", "--repo"], args) | rpath = dispatch._earlygetopt(["-R", "--repository", "--repo"], args) | ||||
| path, newlui = dispatch._getlocal(newui, rpath, wd=cwd) | path, newlui = dispatch._getlocal(newui, rpath, wd=cwd) | ||||
| return (newui, newlui) | return newui, newlui | ||||
| class channeledsystem(object): | class channeledsystem(object): | ||||
| """Propagate ui.system() request in the following format: | """Propagate ui.system() request in the following format: | ||||
| payload length (unsigned int), | payload length (unsigned int), | ||||
| type, '\0', | type, '\0', | ||||
| cmd, '\0', | cmd, '\0', | ||||
| cwd, '\0', | cwd, '\0', | ||||
| def _getrepostate(repo): | def _getrepostate(repo): | ||||
| # experimental config: commands.status.skipstates | # experimental config: commands.status.skipstates | ||||
| skip = set(repo.ui.configlist('commands', 'status.skipstates')) | skip = set(repo.ui.configlist('commands', 'status.skipstates')) | ||||
| for state, statedetectionpredicate, msgfn in STATES: | for state, statedetectionpredicate, msgfn in STATES: | ||||
| if state in skip: | if state in skip: | ||||
| continue | continue | ||||
| if statedetectionpredicate(repo): | if statedetectionpredicate(repo): | ||||
| return (state, statedetectionpredicate, msgfn) | return state, statedetectionpredicate, msgfn | ||||
| def morestatus(repo, fm): | def morestatus(repo, fm): | ||||
| statetuple = _getrepostate(repo) | statetuple = _getrepostate(repo) | ||||
| label = 'status.morestatus' | label = 'status.morestatus' | ||||
| if statetuple: | if statetuple: | ||||
| fm.startitem() | fm.startitem() | ||||
| state, statedetectionpredicate, helpfulmsg = statetuple | state, statedetectionpredicate, helpfulmsg = statetuple | ||||
| statemsg = _('The repository is in an unfinished *%s* state.') % state | statemsg = _('The repository is in an unfinished *%s* state.') % state | ||||
| nocommit = opts.get('no_commit') | nocommit = opts.get('no_commit') | ||||
| importbranch = opts.get('import_branch') | importbranch = opts.get('import_branch') | ||||
| update = not opts.get('bypass') | update = not opts.get('bypass') | ||||
| strip = opts["strip"] | strip = opts["strip"] | ||||
| prefix = opts["prefix"] | prefix = opts["prefix"] | ||||
| sim = float(opts.get('similarity') or 0) | sim = float(opts.get('similarity') or 0) | ||||
| if not tmpname: | if not tmpname: | ||||
| return (None, None, False) | return None, None, False | ||||
| rejects = False | rejects = False | ||||
| try: | try: | ||||
| cmdline_message = logmessage(ui, opts) | cmdline_message = logmessage(ui, opts) | ||||
| if cmdline_message: | if cmdline_message: | ||||
| # pickup the cmdline msg | # pickup the cmdline msg | ||||
| message = cmdline_message | message = cmdline_message | ||||
| # and branch bits | # and branch bits | ||||
| ui.warn(_("warning: can't check exact import with --no-commit\n")) | ui.warn(_("warning: can't check exact import with --no-commit\n")) | ||||
| elif opts.get('exact') and hex(n) != nodeid: | elif opts.get('exact') and hex(n) != nodeid: | ||||
| raise error.Abort(_('patch is damaged or loses information')) | raise error.Abort(_('patch is damaged or loses information')) | ||||
| msg = _('applied to working directory') | msg = _('applied to working directory') | ||||
| if n: | if n: | ||||
| # i18n: refers to a short changeset id | # i18n: refers to a short changeset id | ||||
| msg = _('created %s') % short(n) | msg = _('created %s') % short(n) | ||||
| return (msg, n, rejects) | return msg, n, rejects | ||||
| finally: | finally: | ||||
| os.unlink(tmpname) | os.unlink(tmpname) | ||||
| # facility to let extensions include additional data in an exported patch | # facility to let extensions include additional data in an exported patch | ||||
| # list of identifiers to be executed in order | # list of identifiers to be executed in order | ||||
| extraexport = [] | extraexport = [] | ||||
| # mapping from identifier to actual export function | # mapping from identifier to actual export function | ||||
| # function as to return a string to be added to the header or None | # function as to return a string to be added to the header or None | ||||
| fc = ctx[f] | fc = ctx[f] | ||||
| fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags()) | fm.write('size flags', '% 10d % 1s ', fc.size(), fc.flags()) | ||||
| fm.data(abspath=f) | fm.data(abspath=f) | ||||
| fm.write('path', fmt, m.rel(f)) | fm.write('path', fmt, m.rel(f)) | ||||
| ret = 0 | ret = 0 | ||||
| for subpath in sorted(ctx.substate): | for subpath in sorted(ctx.substate): | ||||
| submatch = matchmod.subdirmatcher(subpath, m) | submatch = matchmod.subdirmatcher(subpath, m) | ||||
| if (subrepos or m.exact(subpath) or any(submatch.files())): | if subrepos or m.exact(subpath) or any(submatch.files()): | ||||
| sub = ctx.sub(subpath) | sub = ctx.sub(subpath) | ||||
| try: | try: | ||||
| recurse = m.exact(subpath) or subrepos | recurse = m.exact(subpath) or subrepos | ||||
| if sub.printfiles(ui, submatch, fm, fmt, recurse) == 0: | if sub.printfiles(ui, submatch, fm, fmt, recurse) == 0: | ||||
| ret = 0 | ret = 0 | ||||
| except error.LookupError: | except error.LookupError: | ||||
| ui.status(_("skipping missing subrepository: %s\n") | ui.status(_("skipping missing subrepository: %s\n") | ||||
| % m.abs(subpath)) | % m.abs(subpath)) | ||||
| continue | continue | ||||
| if xlist is not None: | if xlist is not None: | ||||
| xlist.append(abs) | xlist.append(abs) | ||||
| if dobackup: | if dobackup: | ||||
| # If in interactive mode, don't automatically create | # If in interactive mode, don't automatically create | ||||
| # .orig files (issue4793) | # .orig files (issue4793) | ||||
| if dobackup == backupinteractive: | if dobackup == backupinteractive: | ||||
| tobackup.add(abs) | tobackup.add(abs) | ||||
| elif (backup <= dobackup or wctx[abs].cmp(ctx[abs])): | elif backup <= dobackup or wctx[abs].cmp(ctx[abs]): | ||||
| bakname = scmutil.origpath(ui, repo, rel) | bakname = scmutil.origpath(ui, repo, rel) | ||||
| ui.note(_('saving current version of %s as %s\n') % | ui.note(_('saving current version of %s as %s\n') % | ||||
| (rel, bakname)) | (rel, bakname)) | ||||
| if not opts.get('dry_run'): | if not opts.get('dry_run'): | ||||
| if interactive: | if interactive: | ||||
| util.copyfile(target, bakname) | util.copyfile(target, bakname) | ||||
| else: | else: | ||||
| util.rename(target, bakname) | util.rename(target, bakname) | ||||
| ret = 0 | ret = 0 | ||||
| try: | try: | ||||
| wlock = repo.wlock() | wlock = repo.wlock() | ||||
| if update: | if update: | ||||
| cmdutil.checkunfinished(repo) | cmdutil.checkunfinished(repo) | ||||
| if (exact or not opts.get('force')): | if exact or not opts.get('force'): | ||||
| cmdutil.bailifchanged(repo) | cmdutil.bailifchanged(repo) | ||||
| if not opts.get('no_commit'): | if not opts.get('no_commit'): | ||||
| lock = repo.lock() | lock = repo.lock() | ||||
| tr = repo.transaction('import') | tr = repo.transaction('import') | ||||
| else: | else: | ||||
| dsguard = dirstateguard.dirstateguard(repo, 'import') | dsguard = dirstateguard.dirstateguard(repo, 'import') | ||||
| parents = repo[None].parents() | parents = repo[None].parents() | ||||
| raise | raise | ||||
| return dest, dbranch, None, None | return dest, dbranch, None, None | ||||
| ui.debug('comparing with %s\n' % util.hidepassword(dest)) | ui.debug('comparing with %s\n' % util.hidepassword(dest)) | ||||
| elif sother is None: | elif sother is None: | ||||
| # there is no explicit destination peer, but source one is invalid | # there is no explicit destination peer, but source one is invalid | ||||
| return dest, dbranch, None, None | return dest, dbranch, None, None | ||||
| else: | else: | ||||
| dother = sother | dother = sother | ||||
| if (source != dest or (sbranch is not None and sbranch != dbranch)): | if source != dest or (sbranch is not None and sbranch != dbranch): | ||||
| common = None | common = None | ||||
| else: | else: | ||||
| common = commoninc | common = commoninc | ||||
| if revs: | if revs: | ||||
| revs = [repo.lookup(rev) for rev in revs] | revs = [repo.lookup(rev) for rev in revs] | ||||
| repo.ui.pushbuffer() | repo.ui.pushbuffer() | ||||
| outgoing = discovery.findcommonoutgoing(repo, dother, onlyheads=revs, | outgoing = discovery.findcommonoutgoing(repo, dother, onlyheads=revs, | ||||
| commoninc=common) | commoninc=common) | ||||
| def backup(self, section, item): | def backup(self, section, item): | ||||
| """return a tuple allowing restore to reinstall a previous value | """return a tuple allowing restore to reinstall a previous value | ||||
| The main reason we need it is because it handles the "no data" case. | The main reason we need it is because it handles the "no data" case. | ||||
| """ | """ | ||||
| try: | try: | ||||
| value = self._data[section][item] | value = self._data[section][item] | ||||
| source = self.source(section, item) | source = self.source(section, item) | ||||
| return (section, item, value, source) | return section, item, value, source | ||||
| except KeyError: | except KeyError: | ||||
| return (section, item) | return section, item | ||||
| def source(self, section, item): | def source(self, section, item): | ||||
| return self._source.get((section, item), "") | return self._source.get((section, item), "") | ||||
| def sections(self): | def sections(self): | ||||
| return sorted(self._data.keys()) | return sorted(self._data.keys()) | ||||
| def items(self, section): | def items(self, section): | ||||
| return list(self._data.get(section, {}).iteritems()) | return list(self._data.get(section, {}).iteritems()) | ||||
| def set(self, section, item, value, source=""): | def set(self, section, item, value, source=""): | ||||
| return text.count("\n") + int(bool(text)) | return text.count("\n") + int(bool(text)) | ||||
| if linenumber: | if linenumber: | ||||
| def decorate(text, rev): | def decorate(text, rev): | ||||
| return ([annotateline(fctx=rev, lineno=i) | return ([annotateline(fctx=rev, lineno=i) | ||||
| for i in xrange(1, lines(text) + 1)], text) | for i in xrange(1, lines(text) + 1)], text) | ||||
| else: | else: | ||||
| def decorate(text, rev): | def decorate(text, rev): | ||||
| return ([annotateline(fctx=rev)] * lines(text), text) | return [annotateline(fctx=rev)] * lines(text), text | ||||
| getlog = util.lrucachefunc(lambda x: self._repo.file(x)) | getlog = util.lrucachefunc(lambda x: self._repo.file(x)) | ||||
| def parents(f): | def parents(f): | ||||
| # Cut _descendantrev here to mitigate the penalty of lazy linkrev | # Cut _descendantrev here to mitigate the penalty of lazy linkrev | ||||
| # adjustment. Otherwise, p._adjustlinkrev() would walk changelog | # adjustment. Otherwise, p._adjustlinkrev() would walk changelog | ||||
| # from the topmost introrev (= srcrev) down to p.linkrev() if it | # from the topmost introrev (= srcrev) down to p.linkrev() if it | ||||
| # isn't an ancestor of the srcrev. | # isn't an ancestor of the srcrev. | ||||
| return None | return None | ||||
| return rp, self._changectx._parents[0]._manifest.get(rp, nullid) | return rp, self._changectx._parents[0]._manifest.get(rp, nullid) | ||||
| def size(self): | def size(self): | ||||
| return self._repo.wvfs.lstat(self._path).st_size | return self._repo.wvfs.lstat(self._path).st_size | ||||
| def date(self): | def date(self): | ||||
| t, tz = self._changectx.date() | t, tz = self._changectx.date() | ||||
| try: | try: | ||||
| return (self._repo.wvfs.lstat(self._path).st_mtime, tz) | return self._repo.wvfs.lstat(self._path).st_mtime, tz | ||||
| except OSError as err: | except OSError as err: | ||||
| if err.errno != errno.ENOENT: | if err.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| return (t, tz) | return t, tz | ||||
| def exists(self): | def exists(self): | ||||
| return self._repo.wvfs.exists(self._path) | return self._repo.wvfs.exists(self._path) | ||||
| def lexists(self): | def lexists(self): | ||||
| return self._repo.wvfs.lexists(self._path) | return self._repo.wvfs.lexists(self._path) | ||||
| def audit(self): | def audit(self): | ||||
| def prettystr(self): | def prettystr(self): | ||||
| return self.linetext | return self.linetext | ||||
| def nextsibling(self): | def nextsibling(self): | ||||
| numlinesinhunk = len(self.hunk.changedlines) | numlinesinhunk = len(self.hunk.changedlines) | ||||
| indexofthisline = self.hunk.changedlines.index(self) | indexofthisline = self.hunk.changedlines.index(self) | ||||
| if (indexofthisline < numlinesinhunk - 1): | if indexofthisline < numlinesinhunk - 1: | ||||
| nextline = self.hunk.changedlines[indexofthisline + 1] | nextline = self.hunk.changedlines[indexofthisline + 1] | ||||
| return nextline | return nextline | ||||
| else: | else: | ||||
| return None | return None | ||||
| def prevsibling(self): | def prevsibling(self): | ||||
| indexofthisline = self.hunk.changedlines.index(self) | indexofthisline = self.hunk.changedlines.index(self) | ||||
| if indexofthisline > 0: | if indexofthisline > 0: | ||||
| # flag which only affects the status display indicating if a node's | # flag which only affects the status display indicating if a node's | ||||
| # children are partially applied (i.e. some applied, some not). | # children are partially applied (i.e. some applied, some not). | ||||
| self.partial = False | self.partial = False | ||||
| def nextsibling(self): | def nextsibling(self): | ||||
| numhunksinheader = len(self.header.hunks) | numhunksinheader = len(self.header.hunks) | ||||
| indexofthishunk = self.header.hunks.index(self) | indexofthishunk = self.header.hunks.index(self) | ||||
| if (indexofthishunk < numhunksinheader - 1): | if indexofthishunk < numhunksinheader - 1: | ||||
| nexthunk = self.header.hunks[indexofthishunk + 1] | nexthunk = self.header.hunks[indexofthishunk + 1] | ||||
| return nexthunk | return nexthunk | ||||
| else: | else: | ||||
| return None | return None | ||||
| def prevsibling(self): | def prevsibling(self): | ||||
| indexofthishunk = self.header.hunks.index(self) | indexofthishunk = self.header.hunks.index(self) | ||||
| if indexofthishunk > 0: | if indexofthishunk > 0: | ||||
| # adjust the 'to'-line offset of the hunk to be correct | # adjust the 'to'-line offset of the hunk to be correct | ||||
| # after de-activating some of the other hunks for this file | # after de-activating some of the other hunks for this file | ||||
| if fixoffset: | if fixoffset: | ||||
| #hnk = copy.copy(hnk) # necessary?? | #hnk = copy.copy(hnk) # necessary?? | ||||
| hnk.toline += fixoffset | hnk.toline += fixoffset | ||||
| else: | else: | ||||
| fixoffset += hnk.removed - hnk.added | fixoffset += hnk.removed - hnk.added | ||||
| return (appliedhunklist, ret) | return appliedhunklist, ret | ||||
| def chunkselector(ui, headerlist, operation=None): | def chunkselector(ui, headerlist, operation=None): | ||||
| """ | """ | ||||
| curses interface to get selection of chunks, and mark the applied flags | curses interface to get selection of chunks, and mark the applied flags | ||||
| of the chosen chunks. | of the chosen chunks. | ||||
| """ | """ | ||||
| ui.write(_('starting interactive selection\n')) | ui.write(_('starting interactive selection\n')) | ||||
| chunkselector = curseschunkselector(headerlist, ui, operation) | chunkselector = curseschunkselector(headerlist, ui, operation) | ||||
| # sort so that reasonable information is on top | # sort so that reasonable information is on top | ||||
| v1records = ms._readrecordsv1() | v1records = ms._readrecordsv1() | ||||
| v2records = ms._readrecordsv2() | v2records = ms._readrecordsv2() | ||||
| order = 'LOml' | order = 'LOml' | ||||
| def key(r): | def key(r): | ||||
| idx = order.find(r[0]) | idx = order.find(r[0]) | ||||
| if idx == -1: | if idx == -1: | ||||
| return (1, r[1]) | return 1, r[1] | ||||
| else: | else: | ||||
| return (0, idx) | return 0, idx | ||||
| v1records.sort(key=key) | v1records.sort(key=key) | ||||
| v2records.sort(key=key) | v2records.sort(key=key) | ||||
| if not v1records and not v2records: | if not v1records and not v2records: | ||||
| ui.write(('no merge state found\n')) | ui.write(('no merge state found\n')) | ||||
| elif not v2records: | elif not v2records: | ||||
| ui.note(('no version 2 merge state\n')) | ui.note(('no version 2 merge state\n')) | ||||
| printrecords(1) | printrecords(1) | ||||
| def dfmtstr(max): | def dfmtstr(max): | ||||
| return basedfmtstr % len(str(max)) | return basedfmtstr % len(str(max)) | ||||
| def pcfmtstr(max, padding=0): | def pcfmtstr(max, padding=0): | ||||
| return basepcfmtstr % (len(str(max)), ' ' * padding) | return basepcfmtstr % (len(str(max)), ' ' * padding) | ||||
| def pcfmt(value, total): | def pcfmt(value, total): | ||||
| if total: | if total: | ||||
| return (value, 100 * float(value) / total) | return value, 100 * float(value) / total | ||||
| else: | else: | ||||
| return value, 100.0 | return value, 100.0 | ||||
| ui.write(('format : %d\n') % format) | ui.write(('format : %d\n') % format) | ||||
| ui.write(('flags : %s\n') % ', '.join(flags)) | ui.write(('flags : %s\n') % ', '.join(flags)) | ||||
| ui.write('\n') | ui.write('\n') | ||||
| fmt = pcfmtstr(totalsize) | fmt = pcfmtstr(totalsize) | ||||
| # N only descendant branch heads are closed | # N only descendant branch heads are closed | ||||
| # x 0 there is only one non-closed branch head | # x 0 there is only one non-closed branch head | ||||
| # N there are some non-closed branch heads | # N there are some non-closed branch heads | ||||
| # ========= ========== | # ========= ========== | ||||
| otherheads = repo.revs('%ln - parents()', heads) | otherheads = repo.revs('%ln - parents()', heads) | ||||
| if repo['.'].closesbranch(): | if repo['.'].closesbranch(): | ||||
| ui.warn(_('no open descendant heads on branch "%s", ' | ui.warn(_('no open descendant heads on branch "%s", ' | ||||
| 'updating to a closed head\n') % | 'updating to a closed head\n') % | ||||
| (currentbranch)) | currentbranch) | ||||
| if otherheads: | if otherheads: | ||||
| ui.warn(_("(committing will reopen the head, " | ui.warn(_("(committing will reopen the head, " | ||||
| "use 'hg heads .' to see %i other heads)\n") % | "use 'hg heads .' to see %i other heads)\n") % | ||||
| (len(otherheads))) | (len(otherheads))) | ||||
| else: | else: | ||||
| ui.warn(_('(committing will reopen branch "%s")\n') % | ui.warn(_('(committing will reopen branch "%s")\n') % | ||||
| (currentbranch)) | currentbranch) | ||||
| elif otherheads: | elif otherheads: | ||||
| curhead = repo['.'] | curhead = repo['.'] | ||||
| ui.status(_('updated to "%s: %s"\n') % (curhead, | ui.status(_('updated to "%s: %s"\n') % (curhead, | ||||
| curhead.description().split('\n')[0])) | curhead.description().split('\n')[0])) | ||||
| ui.status(_('%i other heads for branch "%s"\n') % | ui.status(_('%i other heads for branch "%s"\n') % | ||||
| (len(otherheads), currentbranch)) | (len(otherheads), currentbranch)) | ||||
| def statusotherdests(ui, repo): | def statusotherdests(ui, repo): | ||||
| """Print message about other head""" | """Print message about other head""" | ||||
| # XXX we should probably include a hint: | # XXX we should probably include a hint: | ||||
| # - about what to do | # - about what to do | ||||
| # - how to see such heads | # - how to see such heads | ||||
| if repo._activebookmark: | if repo._activebookmark: | ||||
| _statusotherbook(ui, repo) | _statusotherbook(ui, repo) | ||||
| else: | else: | ||||
| _statusotherbranchheads(ui, repo) | _statusotherbranchheads(ui, repo) | ||||
| kind, p = matchmod._patsplit(pattern, 'glob') | kind, p = matchmod._patsplit(pattern, 'glob') | ||||
| if kind == "subinclude": | if kind == "subinclude": | ||||
| if p not in visited: | if p not in visited: | ||||
| files.append(p) | files.append(p) | ||||
| continue | continue | ||||
| m = matchmod.match(self._root, '', [], [pattern], | m = matchmod.match(self._root, '', [], [pattern], | ||||
| warn=self._ui.warn) | warn=self._ui.warn) | ||||
| if m(f): | if m(f): | ||||
| return (i, lineno, line) | return i, lineno, line | ||||
| visited.add(i) | visited.add(i) | ||||
| return (None, -1, "") | return None, -1, "" | ||||
| def _walkexplicit(self, match, subrepos): | def _walkexplicit(self, match, subrepos): | ||||
| '''Get stat data about the files explicitly specified by match. | '''Get stat data about the files explicitly specified by match. | ||||
| Return a triple (results, dirsfound, dirsnotfound). | Return a triple (results, dirsfound, dirsnotfound). | ||||
| - results is a mapping from filename to stat result. It also contains | - results is a mapping from filename to stat result. It also contains | ||||
| listings mapping subrepos and .hg to None. | listings mapping subrepos and .hg to None. | ||||
| - dirsfound is a list of files found to be directories. | - dirsfound is a list of files found to be directories. | ||||
| if heads: | if heads: | ||||
| allknown = True | allknown = True | ||||
| knownnode = repo.changelog.hasnode # no nodemap until it is filtered | knownnode = repo.changelog.hasnode # no nodemap until it is filtered | ||||
| for h in heads: | for h in heads: | ||||
| if not knownnode(h): | if not knownnode(h): | ||||
| allknown = False | allknown = False | ||||
| break | break | ||||
| if allknown: | if allknown: | ||||
| return (heads, False, heads) | return heads, False, heads | ||||
| res = setdiscovery.findcommonheads(repo.ui, repo, remote, | res = setdiscovery.findcommonheads(repo.ui, repo, remote, | ||||
| abortwhenunrelated=not force) | abortwhenunrelated=not force) | ||||
| common, anyinc, srvheads = res | common, anyinc, srvheads = res | ||||
| return (list(common), anyinc, heads or list(srvheads)) | return list(common), anyinc, heads or list(srvheads) | ||||
| class outgoing(object): | class outgoing(object): | ||||
| '''Represents the set of nodes present in a local repo but not in a | '''Represents the set of nodes present in a local repo but not in a | ||||
| (possibly) remote one. | (possibly) remote one. | ||||
| Members: | Members: | ||||
| missing is a list of all nodes present in local but not in remote. | missing is a list of all nodes present in local but not in remote. | ||||
| else: | else: | ||||
| repo.ui.status(_("remote has heads on branch '%s' that are " | repo.ui.status(_("remote has heads on branch '%s' that are " | ||||
| "not known locally: %s\n") % (branch, heads)) | "not known locally: %s\n") % (branch, heads)) | ||||
| if remoteheads is None: | if remoteheads is None: | ||||
| if len(newhs) > 1: | if len(newhs) > 1: | ||||
| dhs = list(newhs) | dhs = list(newhs) | ||||
| if errormsg is None: | if errormsg is None: | ||||
| errormsg = (_("push creates new branch '%s' " | errormsg = (_("push creates new branch '%s' " | ||||
| "with multiple heads") % (branch)) | "with multiple heads") % branch) | ||||
| hint = _("merge or" | hint = _("merge or" | ||||
| " see 'hg help push' for details about" | " see 'hg help push' for details about" | ||||
| " pushing new heads") | " pushing new heads") | ||||
| elif len(newhs) > len(oldhs): | elif len(newhs) > len(oldhs): | ||||
| # remove bookmarked or existing remote heads from the new heads list | # remove bookmarked or existing remote heads from the new heads list | ||||
| dhs = sorted(newhs - nowarnheads - oldhs) | dhs = sorted(newhs - nowarnheads - oldhs) | ||||
| if dhs: | if dhs: | ||||
| if errormsg is None: | if errormsg is None: | ||||
| # fast path the simple case | # fast path the simple case | ||||
| if len(localcandidate) == 1: | if len(localcandidate) == 1: | ||||
| return unknownheads | set(candidate_newhs), set() | return unknownheads | set(candidate_newhs), set() | ||||
| # actually process branch replacement | # actually process branch replacement | ||||
| while localcandidate: | while localcandidate: | ||||
| nh = localcandidate.pop() | nh = localcandidate.pop() | ||||
| # run this check early to skip the evaluation of the whole branch | # run this check early to skip the evaluation of the whole branch | ||||
| if (torev(nh) in futurecommon or ispublic(torev(nh))): | if torev(nh) in futurecommon or ispublic(torev(nh)): | ||||
| newhs.add(nh) | newhs.add(nh) | ||||
| continue | continue | ||||
| # Get all revs/nodes on the branch exclusive to this head | # Get all revs/nodes on the branch exclusive to this head | ||||
| # (already filtered heads are "ignored")) | # (already filtered heads are "ignored")) | ||||
| branchrevs = unfi.revs('only(%n, (%ln+%ln))', | branchrevs = unfi.revs('only(%n, (%ln+%ln))', | ||||
| nh, localcandidate, newhs) | nh, localcandidate, newhs) | ||||
| branchnodes = [tonode(r) for r in branchrevs] | branchnodes = [tonode(r) for r in branchrevs] | ||||
| def _formatparse(write, inst): | def _formatparse(write, inst): | ||||
| similar = [] | similar = [] | ||||
| if isinstance(inst, error.UnknownIdentifier): | if isinstance(inst, error.UnknownIdentifier): | ||||
| # make sure to check fileset first, as revset can invoke fileset | # make sure to check fileset first, as revset can invoke fileset | ||||
| similar = _getsimilar(inst.symbols, inst.function) | similar = _getsimilar(inst.symbols, inst.function) | ||||
| if len(inst.args) > 1: | if len(inst.args) > 1: | ||||
| write(_("hg: parse error at %s: %s\n") % | write(_("hg: parse error at %s: %s\n") % | ||||
| (inst.args[1], inst.args[0])) | (inst.args[1], inst.args[0])) | ||||
| if (inst.args[0][0] == ' '): | if inst.args[0][0] == ' ': | ||||
| write(_("unexpected leading whitespace\n")) | write(_("unexpected leading whitespace\n")) | ||||
| else: | else: | ||||
| write(_("hg: parse error: %s\n") % inst.args[0]) | write(_("hg: parse error: %s\n") % inst.args[0]) | ||||
| _reportsimilar(write, similar) | _reportsimilar(write, similar) | ||||
| if inst.hint: | if inst.hint: | ||||
| write(_("(%s)\n") % inst.hint) | write(_("(%s)\n") % inst.hint) | ||||
| def _formatargs(args): | def _formatargs(args): | ||||
| raise error.CommandError(cmd, inst) | raise error.CommandError(cmd, inst) | ||||
| # separate global options back out | # separate global options back out | ||||
| for o in commands.globalopts: | for o in commands.globalopts: | ||||
| n = o[1] | n = o[1] | ||||
| options[n] = cmdoptions[n] | options[n] = cmdoptions[n] | ||||
| del cmdoptions[n] | del cmdoptions[n] | ||||
| return (cmd, cmd and entry[0] or None, args, options, cmdoptions) | return cmd, cmd and entry[0] or None, args, options, cmdoptions | ||||
| def _parseconfig(ui, config): | def _parseconfig(ui, config): | ||||
| """parse the --config options from the command line""" | """parse the --config options from the command line""" | ||||
| configs = [] | configs = [] | ||||
| for cfg in config: | for cfg in config: | ||||
| try: | try: | ||||
| name, value = [cfgelem.strip() | name, value = [cfgelem.strip() | ||||
| kwargs['common'] = pullop.common | kwargs['common'] = pullop.common | ||||
| kwargs['heads'] = pullop.heads or pullop.rheads | kwargs['heads'] = pullop.heads or pullop.rheads | ||||
| kwargs['cg'] = pullop.fetch | kwargs['cg'] = pullop.fetch | ||||
| ui = pullop.repo.ui | ui = pullop.repo.ui | ||||
| legacyphase = 'phases' in ui.configlist('devel', 'legacy.exchange') | legacyphase = 'phases' in ui.configlist('devel', 'legacy.exchange') | ||||
| hasbinaryphase = 'heads' in pullop.remotebundle2caps.get('phases', ()) | hasbinaryphase = 'heads' in pullop.remotebundle2caps.get('phases', ()) | ||||
| if (not legacyphase and hasbinaryphase): | if not legacyphase and hasbinaryphase: | ||||
| kwargs['phases'] = True | kwargs['phases'] = True | ||||
| pullop.stepsdone.add('phases') | pullop.stepsdone.add('phases') | ||||
| if 'listkeys' in pullop.remotebundle2caps: | if 'listkeys' in pullop.remotebundle2caps: | ||||
| if 'phases' not in pullop.stepsdone: | if 'phases' not in pullop.stepsdone: | ||||
| kwargs['listkeys'] = ['phases'] | kwargs['listkeys'] = ['phases'] | ||||
| if pullop.remotebookmarks is None: | if pullop.remotebookmarks is None: | ||||
| # make sure to always includes bookmark data when migrating | # make sure to always includes bookmark data when migrating | ||||
| ui.traceback() | ui.traceback() | ||||
| return | return | ||||
| for c in aliases: | for c in aliases: | ||||
| if c.startswith(cmd): | if c.startswith(cmd): | ||||
| cmd = c | cmd = c | ||||
| break | break | ||||
| else: | else: | ||||
| cmd = aliases[0] | cmd = aliases[0] | ||||
| return (cmd, name, mod) | return cmd, name, mod | ||||
| 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 = findcmd(cmd, cmd, path) | ext = findcmd(cmd, cmd, path) | ||||
| if not ext: | if not ext: | ||||
| # otherwise, interrogate each extension until there's a match | # otherwise, interrogate each extension until there's a match | ||||
| return self.addrevision(text, transaction, link, p1, p2) | return self.addrevision(text, transaction, link, p1, p2) | ||||
| def renamed(self, node): | def renamed(self, node): | ||||
| if self.parents(node)[0] != revlog.nullid: | if self.parents(node)[0] != revlog.nullid: | ||||
| return False | return False | ||||
| t = self.revision(node) | t = self.revision(node) | ||||
| m = parsemeta(t)[0] | m = parsemeta(t)[0] | ||||
| if m and "copy" in m: | if m and "copy" in m: | ||||
| return (m["copy"], revlog.bin(m["copyrev"])) | return m["copy"], revlog.bin(m["copyrev"]) | ||||
| return False | return False | ||||
| def size(self, rev): | def size(self, rev): | ||||
| """return the size of a given revision""" | """return the size of a given revision""" | ||||
| # for revisions with renames, we have to go the slow way | # for revisions with renames, we have to go the slow way | ||||
| node = self.node(rev) | node = self.node(rev) | ||||
| if self.renamed(node): | if self.renamed(node): | ||||
| # forcemerge comes from command line arguments, highest priority | # forcemerge comes from command line arguments, highest priority | ||||
| force = ui.config('ui', 'forcemerge') | force = ui.config('ui', 'forcemerge') | ||||
| if force: | if force: | ||||
| toolpath = _findtool(ui, force) | toolpath = _findtool(ui, force) | ||||
| if changedelete and not supportscd(toolpath): | if changedelete and not supportscd(toolpath): | ||||
| return ":prompt", None | return ":prompt", None | ||||
| else: | else: | ||||
| if toolpath: | if toolpath: | ||||
| return (force, util.shellquote(toolpath)) | return force, util.shellquote(toolpath) | ||||
| else: | else: | ||||
| # mimic HGMERGE if given tool not found | # mimic HGMERGE if given tool not found | ||||
| return (force, force) | return force, force | ||||
| # HGMERGE takes next precedence | # HGMERGE takes next precedence | ||||
| hgmerge = encoding.environ.get("HGMERGE") | hgmerge = encoding.environ.get("HGMERGE") | ||||
| if hgmerge: | if hgmerge: | ||||
| if changedelete and not supportscd(hgmerge): | if changedelete and not supportscd(hgmerge): | ||||
| return ":prompt", None | return ":prompt", None | ||||
| else: | else: | ||||
| return (hgmerge, hgmerge) | return hgmerge, hgmerge | ||||
| # then patterns | # then patterns | ||||
| for pat, tool in ui.configitems("merge-patterns"): | for pat, tool in ui.configitems("merge-patterns"): | ||||
| mf = match.match(repo.root, '', [pat]) | mf = match.match(repo.root, '', [pat]) | ||||
| if mf(path) and check(tool, pat, symlink, False, changedelete): | if mf(path) and check(tool, pat, symlink, False, changedelete): | ||||
| toolpath = _findtool(ui, tool) | toolpath = _findtool(ui, tool) | ||||
| return (tool, util.shellquote(toolpath)) | return tool, util.shellquote(toolpath) | ||||
| # then merge tools | # then merge tools | ||||
| tools = {} | tools = {} | ||||
| disabled = set() | disabled = set() | ||||
| for k, v in ui.configitems("merge-tools"): | for k, v in ui.configitems("merge-tools"): | ||||
| t = k.split('.')[0] | t = k.split('.')[0] | ||||
| if t not in tools: | if t not in tools: | ||||
| tools[t] = int(_toolstr(ui, t, "priority")) | tools[t] = int(_toolstr(ui, t, "priority")) | ||||
| if _toolbool(ui, t, "disabled"): | if _toolbool(ui, t, "disabled"): | ||||
| disabled.add(t) | disabled.add(t) | ||||
| names = tools.keys() | names = tools.keys() | ||||
| tools = sorted([(-p, tool) for tool, p in tools.items() | tools = sorted([(-p, tool) for tool, p in tools.items() | ||||
| if tool not in disabled]) | if tool not in disabled]) | ||||
| uimerge = ui.config("ui", "merge") | uimerge = ui.config("ui", "merge") | ||||
| if uimerge: | if uimerge: | ||||
| # external tools defined in uimerge won't be able to handle | # external tools defined in uimerge won't be able to handle | ||||
| # change/delete conflicts | # change/delete conflicts | ||||
| if uimerge not in names and not changedelete: | if uimerge not in names and not changedelete: | ||||
| return (uimerge, uimerge) | return uimerge, uimerge | ||||
| tools.insert(0, (None, uimerge)) # highest priority | tools.insert(0, (None, uimerge)) # highest priority | ||||
| tools.append((None, "hgmerge")) # the old default, if found | tools.append((None, "hgmerge")) # the old default, if found | ||||
| for p, t in tools: | for p, t in tools: | ||||
| if check(t, None, symlink, binary, changedelete): | if check(t, None, symlink, binary, changedelete): | ||||
| toolpath = _findtool(ui, t) | toolpath = _findtool(ui, t) | ||||
| return (t, util.shellquote(toolpath)) | return t, util.shellquote(toolpath) | ||||
| # internal merge or prompt as last resort | # internal merge or prompt as last resort | ||||
| if symlink or binary or changedelete: | if symlink or binary or changedelete: | ||||
| if not changedelete and len(tools): | if not changedelete and len(tools): | ||||
| # any tool is rejected by capability for symlink or binary | # any tool is rejected by capability for symlink or binary | ||||
| ui.warn(_("no tool found to merge %s\n") % path) | ui.warn(_("no tool found to merge %s\n") % path) | ||||
| return ":prompt", None | return ":prompt", None | ||||
| return ":merge", None | return ":merge", None | ||||
| if x: | if x: | ||||
| # i18n: "subrepo" is a keyword | # i18n: "subrepo" is a keyword | ||||
| pat = getstring(x, _("subrepo requires a pattern or no arguments")) | pat = getstring(x, _("subrepo requires a pattern or no arguments")) | ||||
| from . import match as matchmod # avoid circular import issues | from . import match as matchmod # avoid circular import issues | ||||
| fast = not matchmod.patkind(pat) | fast = not matchmod.patkind(pat) | ||||
| if fast: | if fast: | ||||
| def m(s): | def m(s): | ||||
| return (s == pat) | return s == pat | ||||
| else: | else: | ||||
| m = matchmod.match(ctx.repo().root, '', [pat], ctx=ctx) | m = matchmod.match(ctx.repo().root, '', [pat], ctx=ctx) | ||||
| return [sub for sub in sstate if m(sub)] | return [sub for sub in sstate if m(sub)] | ||||
| else: | else: | ||||
| return [sub for sub in sstate] | return [sub for sub in sstate] | ||||
| methods = { | methods = { | ||||
| 'string': stringset, | 'string': stringset, | ||||
| visit.append(prev) | visit.append(prev) | ||||
| candidates.sort() | candidates.sort() | ||||
| # have we narrowed it down to one entry? | # have we narrowed it down to one entry? | ||||
| # or have all other possible candidates besides 'bad' have been skipped? | # or have all other possible candidates besides 'bad' have been skipped? | ||||
| tot = len(candidates) | tot = len(candidates) | ||||
| unskipped = [c for c in candidates if (c not in skip) and (c != badrev)] | unskipped = [c for c in candidates if (c not in skip) and (c != badrev)] | ||||
| if tot == 1 or not unskipped: | if tot == 1 or not unskipped: | ||||
| return ([changelog.node(c) for c in candidates], 0, good) | return [changelog.node(c) for c in candidates], 0, good | ||||
| perfect = tot // 2 | perfect = tot // 2 | ||||
| # find the best node to test | # find the best node to test | ||||
| best_rev = None | best_rev = None | ||||
| best_len = -1 | best_len = -1 | ||||
| poison = set() | poison = set() | ||||
| for rev in candidates: | for rev in candidates: | ||||
| if rev in poison: | if rev in poison: | ||||
| if ancestors[c]: | if ancestors[c]: | ||||
| ancestors[c] = list(set(ancestors[c] + a)) | ancestors[c] = list(set(ancestors[c] + a)) | ||||
| else: | else: | ||||
| ancestors[c] = a + [c] | ancestors[c] = a + [c] | ||||
| assert best_rev is not None | assert best_rev is not None | ||||
| best_node = changelog.node(best_rev) | best_node = changelog.node(best_rev) | ||||
| return ([best_node], tot, good) | return [best_node], tot, good | ||||
| def extendrange(repo, state, nodes, good): | def extendrange(repo, state, nodes, good): | ||||
| # bisect is incomplete when it ends on a merge node and | # bisect is incomplete when it ends on a merge node and | ||||
| # one of the parent was not checked. | # one of the parent was not checked. | ||||
| parents = repo[nodes[0]].parents() | parents = repo[nodes[0]].parents() | ||||
| if len(parents) > 1: | if len(parents) > 1: | ||||
| if good: | if good: | ||||
| side = state['bad'] | side = state['bad'] | ||||
| release = lock.release | release = lock.release | ||||
| # shared features | # shared features | ||||
| sharedbookmarks = 'bookmarks' | sharedbookmarks = 'bookmarks' | ||||
| def _local(path): | def _local(path): | ||||
| path = util.expandpath(util.urllocalpath(path)) | path = util.expandpath(util.urllocalpath(path)) | ||||
| return (os.path.isfile(path) and bundlerepo or localrepo) | return os.path.isfile(path) and bundlerepo or localrepo | ||||
| def addbranchrevs(lrepo, other, branches, revs): | def addbranchrevs(lrepo, other, branches, revs): | ||||
| peer = other.peer() # a courtesy to callers using a localrepo for other | peer = other.peer() # a courtesy to callers using a localrepo for other | ||||
| hashbranch, branches = branches | hashbranch, branches = branches | ||||
| if not hashbranch and not branches: | if not hashbranch and not branches: | ||||
| x = revs or None | x = revs or None | ||||
| if util.safehasattr(revs, 'first'): | if util.safehasattr(revs, 'first'): | ||||
| y = revs.first() | y = revs.first() | ||||
| The return is: | The return is: | ||||
| - a single element tuple | - a single element tuple | ||||
| - containing a dictionary with a `before` and `after` key | - containing a dictionary with a `before` and `after` key | ||||
| - values are generator functions taking arbitrary number of kwargs | - values are generator functions taking arbitrary number of kwargs | ||||
| - yield items are dictionaries with `label` and `node` keys | - yield items are dictionaries with `label` and `node` keys | ||||
| """ | """ | ||||
| if not self: | if not self: | ||||
| # empty repo | # empty repo | ||||
| return ({'before': (), 'after': ()},) | return {'before': (), 'after': ()}, | ||||
| targets = [] | targets = [] | ||||
| for f in _navseq(1, pagelen): | for f in _navseq(1, pagelen): | ||||
| if f > limit: | if f > limit: | ||||
| break | break | ||||
| targets.append(pos + f) | targets.append(pos + f) | ||||
| targets.append(pos - f) | targets.append(pos - f) | ||||
| targets.sort() | targets.sort() | ||||
| # local encoding. | # local encoding. | ||||
| tags = {} | tags = {} | ||||
| for (name, (node, hist)) in alltags.iteritems(): | for (name, (node, hist)) in alltags.iteritems(): | ||||
| if node != nullid: | if node != nullid: | ||||
| tags[encoding.tolocal(name)] = node | tags[encoding.tolocal(name)] = node | ||||
| tags['tip'] = self.changelog.tip() | tags['tip'] = self.changelog.tip() | ||||
| tagtypes = dict([(encoding.tolocal(name), value) | tagtypes = dict([(encoding.tolocal(name), value) | ||||
| for (name, value) in tagtypes.iteritems()]) | for (name, value) in tagtypes.iteritems()]) | ||||
| 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 | ||||
| 'global' : a global tag | 'global' : a global tag | ||||
| None : tag does not exist | None : tag does not exist | ||||
| self.sock = sslutil.wrapsocket(self.sock, keyfile, certfile, | self.sock = sslutil.wrapsocket(self.sock, keyfile, certfile, | ||||
| ui=self._ui, | ui=self._ui, | ||||
| serverhostname=self._host) | serverhostname=self._host) | ||||
| self.file = smtplib.SSLFakeFile(self.sock) | self.file = smtplib.SSLFakeFile(self.sock) | ||||
| self.helo_resp = None | self.helo_resp = None | ||||
| self.ehlo_resp = None | self.ehlo_resp = None | ||||
| self.esmtp_features = {} | self.esmtp_features = {} | ||||
| self.does_esmtp = 0 | self.does_esmtp = 0 | ||||
| return (resp, reply) | return resp, reply | ||||
| class SMTPS(smtplib.SMTP): | class SMTPS(smtplib.SMTP): | ||||
| '''Derived class to verify the peer certificate for SMTPS. | '''Derived class to verify the peer certificate for SMTPS. | ||||
| This class allows to pass any keyword arguments to SSL socket creation. | This class allows to pass any keyword arguments to SSL socket creation. | ||||
| ''' | ''' | ||||
| def __init__(self, ui, keyfile=None, certfile=None, host=None, | def __init__(self, ui, keyfile=None, certfile=None, host=None, | ||||
| **kwargs): | **kwargs): | ||||
| ui.note(_('(verifying remote certificate)\n')) | ui.note(_('(verifying remote certificate)\n')) | ||||
| sslutil.validatesocket(s.sock) | sslutil.validatesocket(s.sock) | ||||
| username = ui.config('smtp', 'username') | username = ui.config('smtp', 'username') | ||||
| password = ui.config('smtp', 'password') | password = ui.config('smtp', 'password') | ||||
| if username and not password: | if username and not password: | ||||
| password = ui.getpass() | password = ui.getpass() | ||||
| if username and password: | if username and password: | ||||
| ui.note(_('(authenticating to mail server as %s)\n') % | ui.note(_('(authenticating to mail server as %s)\n') % | ||||
| (username)) | username) | ||||
| try: | try: | ||||
| s.login(username, password) | s.login(username, password) | ||||
| except smtplib.SMTPException as inst: | except smtplib.SMTPException as inst: | ||||
| raise error.Abort(inst) | raise error.Abort(inst) | ||||
| def send(sender, recipients, msg): | def send(sender, recipients, msg): | ||||
| try: | try: | ||||
| return s.sendmail(sender, recipients, msg) | return s.sendmail(sender, recipients, msg) | ||||
| if pos == -1: | if pos == -1: | ||||
| self.pos += 1 | self.pos += 1 | ||||
| return data | return data | ||||
| zeropos = data.find('\x00', pos) | zeropos = data.find('\x00', pos) | ||||
| hashval = unhexlify(data, self.lm.extrainfo[self.pos], | hashval = unhexlify(data, self.lm.extrainfo[self.pos], | ||||
| zeropos + 1, 40) | zeropos + 1, 40) | ||||
| flags = self.lm._getflags(data, self.pos, zeropos) | flags = self.lm._getflags(data, self.pos, zeropos) | ||||
| self.pos += 1 | self.pos += 1 | ||||
| return (data[pos:zeropos], hashval, flags) | return data[pos:zeropos], hashval, flags | ||||
| __next__ = next | __next__ = next | ||||
| def unhexlify(data, extra, pos, length): | def unhexlify(data, extra, pos, length): | ||||
| s = bin(data[pos:pos + length]) | s = bin(data[pos:pos + length]) | ||||
| if extra: | if extra: | ||||
| s += chr(extra & 0xff) | s += chr(extra & 0xff) | ||||
| return s | return s | ||||
| last = len(self.positions) - 1 | last = len(self.positions) - 1 | ||||
| while first <= last: | while first <= last: | ||||
| midpoint = (first + last)//2 | midpoint = (first + last)//2 | ||||
| nextpos = self.positions[midpoint] | nextpos = self.positions[midpoint] | ||||
| candidate = self._getkey(nextpos) | candidate = self._getkey(nextpos) | ||||
| r = _cmp(key, candidate) | r = _cmp(key, candidate) | ||||
| if r == 0: | if r == 0: | ||||
| return (midpoint, True) | return midpoint, True | ||||
| else: | else: | ||||
| if r < 0: | if r < 0: | ||||
| last = midpoint - 1 | last = midpoint - 1 | ||||
| else: | else: | ||||
| first = midpoint + 1 | first = midpoint + 1 | ||||
| return (first, False) | return first, False | ||||
| def __contains__(self, key): | def __contains__(self, key): | ||||
| return self.bsearch(key) != -1 | return self.bsearch(key) != -1 | ||||
| def _getflags(self, data, needle, pos): | def _getflags(self, data, needle, pos): | ||||
| start = pos + 41 | start = pos + 41 | ||||
| end = data.find("\n", start) | end = data.find("\n", start) | ||||
| if end == -1: | if end == -1: | ||||
| end = len(data) - 1 | end = len(data) - 1 | ||||
| if start == end: | if start == end: | ||||
| return '' | return '' | ||||
| return self.data[start:end] | return self.data[start:end] | ||||
| def __getitem__(self, key): | def __getitem__(self, key): | ||||
| if not isinstance(key, bytes): | if not isinstance(key, bytes): | ||||
| raise TypeError("getitem: manifest keys must be a bytes.") | raise TypeError("getitem: manifest keys must be a bytes.") | ||||
| needle = self.bsearch(key) | needle = self.bsearch(key) | ||||
| if needle == -1: | if needle == -1: | ||||
| raise KeyError | raise KeyError | ||||
| data, pos = self._get(needle) | data, pos = self._get(needle) | ||||
| if pos == -1: | if pos == -1: | ||||
| return (data[1], data[2]) | return data[1], data[2] | ||||
| zeropos = data.find('\x00', pos) | zeropos = data.find('\x00', pos) | ||||
| assert 0 <= needle <= len(self.positions) | assert 0 <= needle <= len(self.positions) | ||||
| assert len(self.extrainfo) == len(self.positions) | assert len(self.extrainfo) == len(self.positions) | ||||
| hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, 40) | hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, 40) | ||||
| flags = self._getflags(data, needle, zeropos) | flags = self._getflags(data, needle, zeropos) | ||||
| return (hashval, flags) | return hashval, flags | ||||
| def __delitem__(self, key): | def __delitem__(self, key): | ||||
| needle, found = self.bsearch2(key) | needle, found = self.bsearch2(key) | ||||
| if not found: | if not found: | ||||
| raise KeyError | raise KeyError | ||||
| cur = self.positions[needle] | cur = self.positions[needle] | ||||
| self.positions = self.positions[:needle] + self.positions[needle + 1:] | self.positions = self.positions[:needle] + self.positions[needle + 1:] | ||||
| self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1:] | self.extrainfo = self.extrainfo[:needle] + self.extrainfo[needle + 1:] | ||||
| m should be a buffer, a memoryview or a byte string. | m should be a buffer, a memoryview or a byte string. | ||||
| s is a byte string''' | s is a byte string''' | ||||
| def advance(i, c): | def advance(i, c): | ||||
| while i < lenm and m[i:i + 1] != c: | while i < lenm and m[i:i + 1] != c: | ||||
| i += 1 | i += 1 | ||||
| return i | return i | ||||
| if not s: | if not s: | ||||
| return (lo, lo) | return lo, lo | ||||
| lenm = len(m) | lenm = len(m) | ||||
| if not hi: | if not hi: | ||||
| hi = lenm | hi = lenm | ||||
| while lo < hi: | while lo < hi: | ||||
| mid = (lo + hi) // 2 | mid = (lo + hi) // 2 | ||||
| start = mid | start = mid | ||||
| while start > 0 and m[start - 1:start] != '\n': | while start > 0 and m[start - 1:start] != '\n': | ||||
| start -= 1 | start -= 1 | ||||
| end = advance(start, '\0') | end = advance(start, '\0') | ||||
| if bytes(m[start:end]) < s: | if bytes(m[start:end]) < s: | ||||
| # we know that after the null there are 40 bytes of sha1 | # we know that after the null there are 40 bytes of sha1 | ||||
| # this translates to the bisect lo = mid + 1 | # this translates to the bisect lo = mid + 1 | ||||
| lo = advance(end + 40, '\n') + 1 | lo = advance(end + 40, '\n') + 1 | ||||
| else: | else: | ||||
| # this translates to the bisect hi = mid | # this translates to the bisect hi = mid | ||||
| hi = start | hi = start | ||||
| end = advance(lo, '\0') | end = advance(lo, '\0') | ||||
| found = m[lo:end] | found = m[lo:end] | ||||
| if s == found: | if s == found: | ||||
| # we know that after the null there are 40 bytes of sha1 | # we know that after the null there are 40 bytes of sha1 | ||||
| end = advance(end + 40, '\n') | end = advance(end + 40, '\n') | ||||
| return (lo, end + 1) | return lo, end + 1 | ||||
| else: | else: | ||||
| return (lo, lo) | return lo, lo | ||||
| def _checkforbidden(l): | def _checkforbidden(l): | ||||
| """Check filenames for illegal characters.""" | """Check filenames for illegal characters.""" | ||||
| for f in l: | for f in l: | ||||
| if '\n' in f or '\r' in f: | if '\n' in f or '\r' in f: | ||||
| raise error.RevlogError( | raise error.RevlogError( | ||||
| _("'\\n' and '\\r' disallowed in filenames: %r") % f) | _("'\\n' and '\\r' disallowed in filenames: %r") % f) | ||||
| dir in self._dirs or | dir in self._dirs or | ||||
| any(parentdir in self._fileset | any(parentdir in self._fileset | ||||
| for parentdir in util.finddirs(dir))) | for parentdir in util.finddirs(dir))) | ||||
| def prefix(self): | def prefix(self): | ||||
| return self._prefix | return self._prefix | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<patternmatcher patterns=%r>' % self._pats) | return '<patternmatcher patterns=%r>' % self._pats | ||||
| class includematcher(basematcher): | class includematcher(basematcher): | ||||
| def __init__(self, root, cwd, kindpats, ctx=None, listsubrepos=False, | def __init__(self, root, cwd, kindpats, ctx=None, listsubrepos=False, | ||||
| badfn=None): | badfn=None): | ||||
| super(includematcher, self).__init__(root, cwd, badfn) | super(includematcher, self).__init__(root, cwd, badfn) | ||||
| self._pats, self.matchfn = _buildmatch(ctx, kindpats, '(?:/|$)', | self._pats, self.matchfn = _buildmatch(ctx, kindpats, '(?:/|$)', | ||||
| return 'all' | return 'all' | ||||
| return ('.' in self._roots or | return ('.' in self._roots or | ||||
| dir in self._roots or | dir in self._roots or | ||||
| dir in self._dirs or | dir in self._dirs or | ||||
| any(parentdir in self._roots | any(parentdir in self._roots | ||||
| for parentdir in util.finddirs(dir))) | for parentdir in util.finddirs(dir))) | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<includematcher includes=%r>' % self._pats) | return '<includematcher includes=%r>' % self._pats | ||||
| class exactmatcher(basematcher): | class exactmatcher(basematcher): | ||||
| '''Matches the input files exactly. They are interpreted as paths, not | '''Matches the input files exactly. They are interpreted as paths, not | ||||
| patterns (so no kind-prefixes). | patterns (so no kind-prefixes). | ||||
| ''' | ''' | ||||
| def __init__(self, root, cwd, files, badfn=None): | def __init__(self, root, cwd, files, badfn=None): | ||||
| super(exactmatcher, self).__init__(root, cwd, badfn) | super(exactmatcher, self).__init__(root, cwd, badfn) | ||||
| def visitdir(self, dir): | def visitdir(self, dir): | ||||
| return dir in self._dirs | return dir in self._dirs | ||||
| def isexact(self): | def isexact(self): | ||||
| return True | return True | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<exactmatcher files=%r>' % self._files) | return '<exactmatcher files=%r>' % self._files | ||||
| class differencematcher(basematcher): | class differencematcher(basematcher): | ||||
| '''Composes two matchers by matching if the first matches and the second | '''Composes two matchers by matching if the first matches and the second | ||||
| does not. Well, almost... If the user provides a pattern like "-X foo foo", | does not. Well, almost... If the user provides a pattern like "-X foo foo", | ||||
| Mercurial actually does match "foo" against that. That's because exact | Mercurial actually does match "foo" against that. That's because exact | ||||
| matches are treated specially. So, since this differencematcher is used for | matches are treated specially. So, since this differencematcher is used for | ||||
| excludes, it needs to special-case exact matching. | excludes, it needs to special-case exact matching. | ||||
| # exception we have for exact matches. | # exception we have for exact matches. | ||||
| return False | return False | ||||
| return bool(self._m1.visitdir(dir)) | return bool(self._m1.visitdir(dir)) | ||||
| def isexact(self): | def isexact(self): | ||||
| return self._m1.isexact() | return self._m1.isexact() | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)) | return '<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2) | ||||
| def intersectmatchers(m1, m2): | def intersectmatchers(m1, m2): | ||||
| '''Composes two matchers by matching if both of them match. | '''Composes two matchers by matching if both of them match. | ||||
| The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, | The second matcher's non-matching-attributes (root, cwd, bad, explicitdir, | ||||
| traversedir) are ignored. | traversedir) are ignored. | ||||
| ''' | ''' | ||||
| if m1 is None or m2 is None: | if m1 is None or m2 is None: | ||||
| def always(self): | def always(self): | ||||
| return self._m1.always() and self._m2.always() | return self._m1.always() and self._m2.always() | ||||
| def isexact(self): | def isexact(self): | ||||
| return self._m1.isexact() or self._m2.isexact() | return self._m1.isexact() or self._m2.isexact() | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2)) | return '<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2) | ||||
| class subdirmatcher(basematcher): | class subdirmatcher(basematcher): | ||||
| """Adapt a matcher to work on a subdirectory only. | """Adapt a matcher to work on a subdirectory only. | ||||
| The paths are remapped to remove/insert the path as needed: | The paths are remapped to remove/insert the path as needed: | ||||
| >>> from . import pycompat | >>> from . import pycompat | ||||
| >>> m1 = match(b'root', b'', [b'a.txt', b'sub/b.txt']) | >>> m1 = match(b'root', b'', [b'a.txt', b'sub/b.txt']) | ||||
| for m in self._matchers: | for m in self._matchers: | ||||
| v = m.visitdir(dir) | v = m.visitdir(dir) | ||||
| if v == 'all': | if v == 'all': | ||||
| return v | return v | ||||
| r |= v | r |= v | ||||
| return r | return r | ||||
| def __repr__(self): | def __repr__(self): | ||||
| return ('<unionmatcher matchers=%r>' % self._matchers) | return '<unionmatcher matchers=%r>' % self._matchers | ||||
| def patkind(pattern, default=None): | def patkind(pattern, default=None): | ||||
| '''If pattern is 'kind:pat' with a known kind, return kind.''' | '''If pattern is 'kind:pat' with a known kind, return kind.''' | ||||
| return _patsplit(pattern, default)[0] | return _patsplit(pattern, default)[0] | ||||
| def _patsplit(pattern, default): | def _patsplit(pattern, default): | ||||
| """Split a string into the optional pattern kind prefix and the actual | """Split a string into the optional pattern kind prefix and the actual | ||||
| pattern.""" | pattern.""" | ||||
| # check whether sub state is modified | # check whether sub state is modified | ||||
| if any(wctx.sub(s).dirty() for s in wctx.substate): | if any(wctx.sub(s).dirty() for s in wctx.substate): | ||||
| m1['.hgsubstate'] = modifiednodeid | m1['.hgsubstate'] = modifiednodeid | ||||
| # Don't use m2-vs-ma optimization if: | # Don't use m2-vs-ma optimization if: | ||||
| # - ma is the same as m1 or m2, which we're just going to diff again later | # - ma is the same as m1 or m2, which we're just going to diff again later | ||||
| # - The caller specifically asks for a full diff, which is useful during bid | # - The caller specifically asks for a full diff, which is useful during bid | ||||
| # merge. | # merge. | ||||
| if (pa not in ([wctx, p2] + wctx.parents()) and not forcefulldiff): | if pa not in ([wctx, p2] + wctx.parents()) and not forcefulldiff: | ||||
| # 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 copy.iteritems(): | for copykey, copyvalue in copy.iteritems(): | ||||
| if copyvalue in relevantfiles: | if copyvalue in relevantfiles: | ||||
| longoptionarg = m.group(5).strip() | longoptionarg = m.group(5).strip() | ||||
| blocks[j]['lines'][0] = desc | blocks[j]['lines'][0] = desc | ||||
| noshortop = '' | noshortop = '' | ||||
| if not shortoption: | if not shortoption: | ||||
| noshortop = ' ' | noshortop = ' ' | ||||
| opt = "%s%s" % (shortoption and "-%s " % shortoption or '', | opt = "%s%s" % (shortoption and "-%s " % shortoption or '', | ||||
| ("%s--%s %s") % (noshortop, longoption, | "%s--%s %s" % (noshortop, longoption, | ||||
| longoptionarg)) | longoptionarg)) | ||||
| opt = opt.rstrip() | opt = opt.rstrip() | ||||
| blocks[j]['optstr'] = opt | blocks[j]['optstr'] = opt | ||||
| optstrwidth = max(optstrwidth, encoding.colwidth(opt)) | optstrwidth = max(optstrwidth, encoding.colwidth(opt)) | ||||
| j += 1 | j += 1 | ||||
| for block in blocks[i:j]: | for block in blocks[i:j]: | ||||
| block['optstrwidth'] = optstrwidth | block['optstrwidth'] = optstrwidth | ||||
| i = j + 1 | i = j + 1 | ||||
| 'warning': _('Warning!'), | 'warning': _('Warning!'), | ||||
| } | } | ||||
| def formatoption(block, width): | def formatoption(block, width): | ||||
| desc = ' '.join(map(bytes.strip, block['lines'])) | desc = ' '.join(map(bytes.strip, block['lines'])) | ||||
| colwidth = encoding.colwidth(block['optstr']) | colwidth = encoding.colwidth(block['optstr']) | ||||
| usablewidth = width - 1 | usablewidth = width - 1 | ||||
| hanging = block['optstrwidth'] | hanging = block['optstrwidth'] | ||||
| initindent = '%s%s ' % (block['optstr'], ' ' * ((hanging - colwidth))) | initindent = '%s%s ' % (block['optstr'], ' ' * (hanging - colwidth)) | ||||
| hangindent = ' ' * (encoding.colwidth(initindent) + 1) | hangindent = ' ' * (encoding.colwidth(initindent) + 1) | ||||
| return ' %s\n' % (util.wrap(desc, usablewidth, | return ' %s\n' % (util.wrap(desc, usablewidth, | ||||
| initindent=initindent, | initindent=initindent, | ||||
| hangindent=hangindent)) | hangindent=hangindent)) | ||||
| def formatblock(block, width): | def formatblock(block, width): | ||||
| """Format a block according to width.""" | """Format a block according to width.""" | ||||
| if width <= 0: | if width <= 0: | ||||
| """Returns True if the given repository has the given obsolete option | """Returns True if the given repository has the given obsolete option | ||||
| enabled. | enabled. | ||||
| """ | """ | ||||
| createmarkersvalue = _getoptionvalue(repo, createmarkersopt) | createmarkersvalue = _getoptionvalue(repo, createmarkersopt) | ||||
| unstabluevalue = _getoptionvalue(repo, allowunstableopt) | unstabluevalue = _getoptionvalue(repo, allowunstableopt) | ||||
| exchangevalue = _getoptionvalue(repo, exchangeopt) | exchangevalue = _getoptionvalue(repo, exchangeopt) | ||||
| # createmarkers must be enabled if other options are enabled | # createmarkers must be enabled if other options are enabled | ||||
| if ((unstabluevalue or exchangevalue) and not createmarkersvalue): | if (unstabluevalue or exchangevalue) and not createmarkersvalue: | ||||
| raise error.Abort(_("'createmarkers' obsolete option must be enabled " | raise error.Abort(_("'createmarkers' obsolete option must be enabled " | ||||
| "if other obsolete options are enabled")) | "if other obsolete options are enabled")) | ||||
| return _getoptionvalue(repo, option) | return _getoptionvalue(repo, option) | ||||
| ### obsolescence marker flag | ### obsolescence marker flag | ||||
| ## bumpedfix flag | ## bumpedfix flag | ||||
| - binary data is base85 encoded | - binary data is base85 encoded | ||||
| - split in chunks smaller than 5300 bytes""" | - split in chunks smaller than 5300 bytes""" | ||||
| keys = {} | keys = {} | ||||
| parts = [] | parts = [] | ||||
| currentlen = _maxpayload * 2 # ensure we create a new part | currentlen = _maxpayload * 2 # ensure we create a new part | ||||
| for marker in markers: | for marker in markers: | ||||
| nextdata = _fm0encodeonemarker(marker) | nextdata = _fm0encodeonemarker(marker) | ||||
| if (len(nextdata) + currentlen > _maxpayload): | if len(nextdata) + currentlen > _maxpayload: | ||||
| currentpart = [] | currentpart = [] | ||||
| currentlen = 0 | currentlen = 0 | ||||
| parts.append(currentpart) | parts.append(currentpart) | ||||
| currentpart.append(nextdata) | currentpart.append(nextdata) | ||||
| currentlen += len(nextdata) | currentlen += len(nextdata) | ||||
| for idx, part in enumerate(reversed(parts)): | for idx, part in enumerate(reversed(parts)): | ||||
| data = ''.join([_pack('>B', _fm0version)] + part) | data = ''.join([_pack('>B', _fm0version)] + part) | ||||
| keys['dump%i' % idx] = util.b85encode(data) | keys['dump%i' % idx] = util.b85encode(data) | ||||
| >>> builddecl(b'foo("bar') | >>> builddecl(b'foo("bar') | ||||
| ('foo("bar', None, 'at 5: unterminated string') | ('foo("bar', None, 'at 5: unterminated string') | ||||
| >>> builddecl(b'foo($1, $2, $1)') | >>> builddecl(b'foo($1, $2, $1)') | ||||
| ('foo', None, 'argument names collide with each other') | ('foo', None, 'argument names collide with each other') | ||||
| """ | """ | ||||
| try: | try: | ||||
| tree = cls._parse(decl) | tree = cls._parse(decl) | ||||
| except error.ParseError as inst: | except error.ParseError as inst: | ||||
| return (decl, None, parseerrordetail(inst)) | return decl, None, parseerrordetail(inst) | ||||
| if tree[0] == cls._symbolnode: | if tree[0] == cls._symbolnode: | ||||
| # "name = ...." style | # "name = ...." style | ||||
| name = tree[1] | name = tree[1] | ||||
| if name.startswith('$'): | if name.startswith('$'): | ||||
| return (decl, None, _("invalid symbol '%s'") % name) | return decl, None, _("invalid symbol '%s'") % name | ||||
| return (name, None, None) | return name, None, None | ||||
| func = cls._trygetfunc(tree) | func = cls._trygetfunc(tree) | ||||
| if func: | if func: | ||||
| # "name(arg, ....) = ...." style | # "name(arg, ....) = ...." style | ||||
| name, args = func | name, args = func | ||||
| if name.startswith('$'): | if name.startswith('$'): | ||||
| return (decl, None, _("invalid function '%s'") % name) | return decl, None, _("invalid function '%s'") % name | ||||
| if any(t[0] != cls._symbolnode for t in args): | if any(t[0] != cls._symbolnode for t in args): | ||||
| return (decl, None, _("invalid argument list")) | return decl, None, _("invalid argument list") | ||||
| if len(args) != len(set(args)): | if len(args) != len(set(args)): | ||||
| return (name, None, _("argument names collide with each other")) | return name, None, _("argument names collide with each other") | ||||
| return (name, [t[1] for t in args], None) | return name, [t[1] for t in args], None | ||||
| return (decl, None, _("invalid format")) | return decl, None, _("invalid format") | ||||
| @classmethod | @classmethod | ||||
| def _relabelargs(cls, tree, args): | def _relabelargs(cls, tree, args): | ||||
| """Mark alias arguments as ``_aliasarg``""" | """Mark alias arguments as ``_aliasarg``""" | ||||
| if not isinstance(tree, tuple): | if not isinstance(tree, tuple): | ||||
| return tree | return tree | ||||
| op = tree[0] | op = tree[0] | ||||
| if op != cls._symbolnode: | if op != cls._symbolnode: | ||||
| return (op,) + tuple(cls._relabelargs(x, args) for x in tree[1:]) | return (op,) + tuple(cls._relabelargs(x, args) for x in tree[1:]) | ||||
| assert len(tree) == 2 | assert len(tree) == 2 | ||||
| sym = tree[1] | sym = tree[1] | ||||
| if sym in args: | if sym in args: | ||||
| op = '_aliasarg' | op = '_aliasarg' | ||||
| elif sym.startswith('$'): | elif sym.startswith('$'): | ||||
| raise error.ParseError(_("invalid symbol '%s'") % sym) | raise error.ParseError(_("invalid symbol '%s'") % sym) | ||||
| return (op, sym) | return op, sym | ||||
| @classmethod | @classmethod | ||||
| def _builddefn(cls, defn, args): | def _builddefn(cls, defn, args): | ||||
| """Parse an alias definition into a tree and marks substitutions | """Parse an alias definition into a tree and marks substitutions | ||||
| This function marks alias argument references as ``_aliasarg``. The | This function marks alias argument references as ``_aliasarg``. The | ||||
| parsing rule is provided by ``_parse()``. | parsing rule is provided by ``_parse()``. | ||||
| class fsbackend(abstractbackend): | class fsbackend(abstractbackend): | ||||
| def __init__(self, ui, basedir): | def __init__(self, ui, basedir): | ||||
| super(fsbackend, self).__init__(ui) | super(fsbackend, self).__init__(ui) | ||||
| self.opener = vfsmod.vfs(basedir) | self.opener = vfsmod.vfs(basedir) | ||||
| def getfile(self, fname): | def getfile(self, fname): | ||||
| if self.opener.islink(fname): | if self.opener.islink(fname): | ||||
| return (self.opener.readlink(fname), (True, False)) | return self.opener.readlink(fname), (True, False) | ||||
| isexec = False | isexec = False | ||||
| try: | try: | ||||
| isexec = self.opener.lstat(fname).st_mode & 0o100 != 0 | isexec = self.opener.lstat(fname).st_mode & 0o100 != 0 | ||||
| except OSError as e: | except OSError as e: | ||||
| if e.errno != errno.ENOENT: | if e.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| try: | try: | ||||
| return (self.opener.read(fname), (False, isexec)) | return self.opener.read(fname), (False, isexec) | ||||
| except IOError as e: | except IOError as e: | ||||
| if e.errno != errno.ENOENT: | if e.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| return None, None | return None, None | ||||
| def setfile(self, fname, data, mode, copysource): | def setfile(self, fname, data, mode, copysource): | ||||
| islink, isexec = mode | islink, isexec = mode | ||||
| if data is None: | if data is None: | ||||
| s = deltahead(binchunk) | s = deltahead(binchunk) | ||||
| binchunk = binchunk[s:] | binchunk = binchunk[s:] | ||||
| s = deltahead(binchunk) | s = deltahead(binchunk) | ||||
| binchunk = binchunk[s:] | binchunk = binchunk[s:] | ||||
| i = 0 | i = 0 | ||||
| while i < len(binchunk): | while i < len(binchunk): | ||||
| cmd = ord(binchunk[i]) | cmd = ord(binchunk[i]) | ||||
| i += 1 | i += 1 | ||||
| if (cmd & 0x80): | if cmd & 0x80: | ||||
| offset = 0 | offset = 0 | ||||
| size = 0 | size = 0 | ||||
| if (cmd & 0x01): | if cmd & 0x01: | ||||
| offset = ord(binchunk[i]) | offset = ord(binchunk[i]) | ||||
| i += 1 | i += 1 | ||||
| if (cmd & 0x02): | if cmd & 0x02: | ||||
| offset |= ord(binchunk[i]) << 8 | offset |= ord(binchunk[i]) << 8 | ||||
| i += 1 | i += 1 | ||||
| if (cmd & 0x04): | if cmd & 0x04: | ||||
| offset |= ord(binchunk[i]) << 16 | offset |= ord(binchunk[i]) << 16 | ||||
| i += 1 | i += 1 | ||||
| if (cmd & 0x08): | if cmd & 0x08: | ||||
| offset |= ord(binchunk[i]) << 24 | offset |= ord(binchunk[i]) << 24 | ||||
| i += 1 | i += 1 | ||||
| if (cmd & 0x10): | if cmd & 0x10: | ||||
| size = ord(binchunk[i]) | size = ord(binchunk[i]) | ||||
| i += 1 | i += 1 | ||||
| if (cmd & 0x20): | if cmd & 0x20: | ||||
| size |= ord(binchunk[i]) << 8 | size |= ord(binchunk[i]) << 8 | ||||
| i += 1 | i += 1 | ||||
| if (cmd & 0x40): | if cmd & 0x40: | ||||
| size |= ord(binchunk[i]) << 16 | size |= ord(binchunk[i]) << 16 | ||||
| i += 1 | i += 1 | ||||
| if size == 0: | if size == 0: | ||||
| size = 0x10000 | size = 0x10000 | ||||
| offset_end = offset + size | offset_end = offset + size | ||||
| out += data[offset:offset_end] | out += data[offset:offset_end] | ||||
| elif cmd != 0: | elif cmd != 0: | ||||
| offset_end = i + cmd | offset_end = i + cmd | ||||
| _('illegal ssh hostname or username starting with -: %s') % args) | _('illegal ssh hostname or username starting with -: %s') % args) | ||||
| args = shellquote(args) | args = shellquote(args) | ||||
| if port: | if port: | ||||
| args = '-p %s %s' % (shellquote(port), args) | args = '-p %s %s' % (shellquote(port), args) | ||||
| return args | return args | ||||
| def isexec(f): | def isexec(f): | ||||
| """check whether a file is executable""" | """check whether a file is executable""" | ||||
| return (os.lstat(f).st_mode & 0o100 != 0) | return os.lstat(f).st_mode & 0o100 != 0 | ||||
| def setflags(f, l, x): | def setflags(f, l, x): | ||||
| st = os.lstat(f) | st = os.lstat(f) | ||||
| s = st.st_mode | s = st.st_mode | ||||
| if l: | if l: | ||||
| if not stat.S_ISLNK(s): | if not stat.S_ISLNK(s): | ||||
| # switch file to link | # switch file to link | ||||
| fp = open(f) | fp = open(f) | ||||
| ui._isatty(ui.ferr) or ui.configbool('progress', 'assume-tty')) | ui._isatty(ui.ferr) or ui.configbool('progress', 'assume-tty')) | ||||
| def fmtremaining(seconds): | def fmtremaining(seconds): | ||||
| """format a number of remaining seconds in human readable way | """format a number of remaining seconds in human readable way | ||||
| This will properly display seconds, minutes, hours, days if needed""" | This will properly display seconds, minutes, hours, days if needed""" | ||||
| if seconds < 60: | if seconds < 60: | ||||
| # i18n: format XX seconds as "XXs" | # i18n: format XX seconds as "XXs" | ||||
| return _("%02ds") % (seconds) | return _("%02ds") % seconds | ||||
| minutes = seconds // 60 | minutes = seconds // 60 | ||||
| if minutes < 60: | if minutes < 60: | ||||
| seconds -= minutes * 60 | seconds -= minutes * 60 | ||||
| # i18n: format X minutes and YY seconds as "XmYYs" | # i18n: format X minutes and YY seconds as "XmYYs" | ||||
| return _("%dm%02ds") % (minutes, seconds) | return _("%dm%02ds") % (minutes, seconds) | ||||
| # we're going to ignore seconds in this case | # we're going to ignore seconds in this case | ||||
| minutes += 1 | minutes += 1 | ||||
| hours = minutes // 60 | hours = minutes // 60 | ||||
| def b85encode(text, pad=False): | def b85encode(text, pad=False): | ||||
| """encode text in base85 format""" | """encode text in base85 format""" | ||||
| l = len(text) | l = len(text) | ||||
| r = l % 4 | r = l % 4 | ||||
| if r: | if r: | ||||
| text += '\0' * (4 - r) | text += '\0' * (4 - r) | ||||
| longs = len(text) >> 2 | longs = len(text) >> 2 | ||||
| words = struct.unpack('>%dL' % (longs), text) | words = struct.unpack('>%dL' % longs, text) | ||||
| out = ''.join(_b85chars[(word // 52200625) % 85] + | out = ''.join(_b85chars[(word // 52200625) % 85] + | ||||
| _b85chars2[(word // 7225) % 7225] + | _b85chars2[(word // 7225) % 7225] + | ||||
| _b85chars2[word % 7225] | _b85chars2[word % 7225] | ||||
| for word in words) | for word in words) | ||||
| if pad: | if pad: | ||||
| return out | return out | ||||
| m.seek(dest) | m.seek(dest) | ||||
| m.write(buf) | m.write(buf) | ||||
| def _collect(m, buf, list): | def _collect(m, buf, list): | ||||
| start = buf | start = buf | ||||
| for l, p in reversed(list): | for l, p in reversed(list): | ||||
| _move(m, buf, p, l) | _move(m, buf, p, l) | ||||
| buf += l | buf += l | ||||
| return (buf - start, start) | return buf - start, start | ||||
| def patches(a, bins): | def patches(a, bins): | ||||
| if not bins: | if not bins: | ||||
| return a | return a | ||||
| plens = [len(x) for x in bins] | plens = [len(x) for x in bins] | ||||
| pl = sum(plens) | pl = sum(plens) | ||||
| bl = len(a) + pl | bl = len(a) + pl | ||||
| i = len(self) + i | i = len(self) + i | ||||
| if i < 0 or i >= len(self): | if i < 0 or i >= len(self): | ||||
| raise IndexError | raise IndexError | ||||
| return i | return i | ||||
| def __getitem__(self, i): | def __getitem__(self, i): | ||||
| i = self._fix_index(i) | i = self._fix_index(i) | ||||
| if i == len(self) - 1: | if i == len(self) - 1: | ||||
| return (0, 0, 0, -1, -1, -1, -1, nullid) | return 0, 0, 0, -1, -1, -1, -1, nullid | ||||
| if i >= self._lgt: | if i >= self._lgt: | ||||
| return self._extra[i - self._lgt] | return self._extra[i - self._lgt] | ||||
| index = self._calculate_index(i) | index = self._calculate_index(i) | ||||
| r = struct.unpack(indexformatng, self._data[index:index + indexsize]) | r = struct.unpack(indexformatng, self._data[index:index + indexsize]) | ||||
| if i == 0: | if i == 0: | ||||
| e = list(r) | e = list(r) | ||||
| type = gettype(e[0]) | type = gettype(e[0]) | ||||
| e[0] = offset_type(0, type) | e[0] = offset_type(0, type) | ||||
| should be used to generate hash. Usually, "write" and "read" return | should be used to generate hash. Usually, "write" and "read" return | ||||
| different booleans. And "raw" returns a same boolean as "write". | different booleans. And "raw" returns a same boolean as "write". | ||||
| Note: The 'raw' transform is used for changegroup generation and in some | Note: The 'raw' transform is used for changegroup generation and in some | ||||
| debug commands. In this case the transform only indicates whether the | debug commands. In this case the transform only indicates whether the | ||||
| contents can be used for hash integrity checks. | contents can be used for hash integrity checks. | ||||
| """ | """ | ||||
| if not flag & REVIDX_KNOWN_FLAGS: | if not flag & REVIDX_KNOWN_FLAGS: | ||||
| msg = _("cannot register processor on unknown flag '%#x'.") % (flag) | msg = _("cannot register processor on unknown flag '%#x'.") % flag | ||||
| raise ProgrammingError(msg) | raise ProgrammingError(msg) | ||||
| if flag not in REVIDX_FLAGS_ORDER: | if flag not in REVIDX_FLAGS_ORDER: | ||||
| msg = _("flag '%#x' undefined in REVIDX_FLAGS_ORDER.") % (flag) | msg = _("flag '%#x' undefined in REVIDX_FLAGS_ORDER.") % flag | ||||
| raise ProgrammingError(msg) | raise ProgrammingError(msg) | ||||
| if flag in _flagprocessors: | if flag in _flagprocessors: | ||||
| msg = _("cannot register multiple processors on flag '%#x'.") % (flag) | msg = _("cannot register multiple processors on flag '%#x'.") % flag | ||||
| raise error.Abort(msg) | raise error.Abort(msg) | ||||
| _flagprocessors[flag] = processor | _flagprocessors[flag] = processor | ||||
| def getoffset(q): | def getoffset(q): | ||||
| return int(q >> 16) | return int(q >> 16) | ||||
| def gettype(q): | def gettype(q): | ||||
| return int(q & 0xFFFF) | return int(q & 0xFFFF) | ||||
| self.storedeltachains = True | self.storedeltachains = True | ||||
| self._io = revlogio() | self._io = revlogio() | ||||
| if self.version == REVLOGV0: | if self.version == REVLOGV0: | ||||
| self._io = revlogoldio() | self._io = revlogoldio() | ||||
| try: | try: | ||||
| d = self._io.parseindex(indexdata, self._inline) | d = self._io.parseindex(indexdata, self._inline) | ||||
| except (ValueError, IndexError): | except (ValueError, IndexError): | ||||
| raise RevlogError(_("index %s is corrupted") % (self.indexfile)) | raise RevlogError(_("index %s is corrupted") % self.indexfile) | ||||
| self.index, nodemap, self._chunkcache = d | self.index, nodemap, self._chunkcache = d | ||||
| if nodemap is not None: | if nodemap is not None: | ||||
| self.nodemap = self._nodecache = nodemap | self.nodemap = self._nodecache = nodemap | ||||
| if not self._chunkcache: | if not self._chunkcache: | ||||
| self._chunkclear() | self._chunkclear() | ||||
| # revnum -> (chain-length, sum-delta-length) | # revnum -> (chain-length, sum-delta-length) | ||||
| self._chaininfocache = {} | self._chaininfocache = {} | ||||
| # revlog header -> revlog compressor | # revlog header -> revlog compressor | ||||
| if not roots: | if not roots: | ||||
| return nonodes | return nonodes | ||||
| lowestrev = min([self.rev(n) for n in roots]) | lowestrev = min([self.rev(n) for n in roots]) | ||||
| else: | else: | ||||
| roots = [nullid] # Everybody's a descendant of nullid | roots = [nullid] # Everybody's a descendant of nullid | ||||
| lowestrev = nullrev | lowestrev = nullrev | ||||
| if (lowestrev == nullrev) and (heads is None): | if (lowestrev == nullrev) and (heads is None): | ||||
| # We want _all_ the nodes! | # We want _all_ the nodes! | ||||
| return ([self.node(r) for r in self], [nullid], list(self.heads())) | return [self.node(r) for r in self], [nullid], list(self.heads()) | ||||
| if heads is None: | if heads is None: | ||||
| # All nodes are ancestors, so the latest ancestor is the last | # All nodes are ancestors, so the latest ancestor is the last | ||||
| # node. | # node. | ||||
| highestrev = len(self) - 1 | highestrev = len(self) - 1 | ||||
| # Set ancestors to None to signal that every node is an ancestor. | # Set ancestors to None to signal that every node is an ancestor. | ||||
| ancestors = None | ancestors = None | ||||
| # Set heads to an empty dictionary for later discovery of heads | # Set heads to an empty dictionary for later discovery of heads | ||||
| heads = {} | heads = {} | ||||
| # 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 heads.iteritems() if flag] | heads = [head for head, flag in heads.iteritems() 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): | def headrevs(self): | ||||
| try: | try: | ||||
| return self.index.headrevs() | return self.index.headrevs() | ||||
| except AttributeError: | except AttributeError: | ||||
| return self._headrevs() | return self._headrevs() | ||||
| def computephases(self, roots): | def computephases(self, roots): | ||||
| Note: If the ``raw`` argument is set, it has precedence over the | Note: If the ``raw`` argument is set, it has precedence over the | ||||
| operation and will only update the value of ``validatehash``. | operation and will only update the value of ``validatehash``. | ||||
| """ | """ | ||||
| # fast path: no flag processors will run | # fast path: no flag processors will run | ||||
| if flags == 0: | if flags == 0: | ||||
| return text, True | return text, True | ||||
| if not operation in ('read', 'write'): | if not operation in ('read', 'write'): | ||||
| raise ProgrammingError(_("invalid '%s' operation ") % (operation)) | raise ProgrammingError(_("invalid '%s' operation ") % operation) | ||||
| # Check all flags are known. | # Check all flags are known. | ||||
| if flags & ~REVIDX_KNOWN_FLAGS: | if flags & ~REVIDX_KNOWN_FLAGS: | ||||
| raise RevlogError(_("incompatible revision flag '%#x'") % | raise RevlogError(_("incompatible revision flag '%#x'") % | ||||
| (flags & ~REVIDX_KNOWN_FLAGS)) | (flags & ~REVIDX_KNOWN_FLAGS)) | ||||
| validatehash = True | validatehash = True | ||||
| # Depending on the operation (read or write), the order might be | # Depending on the operation (read or write), the order might be | ||||
| # reversed due to non-commutative transforms. | # reversed due to non-commutative transforms. | ||||
| orderedflags = REVIDX_FLAGS_ORDER | orderedflags = REVIDX_FLAGS_ORDER | ||||
| if operation == 'write': | if operation == 'write': | ||||
| orderedflags = reversed(orderedflags) | orderedflags = reversed(orderedflags) | ||||
| for flag in orderedflags: | for flag in orderedflags: | ||||
| # If a flagprocessor has been registered for a known flag, apply the | # If a flagprocessor has been registered for a known flag, apply the | ||||
| # related operation transform and update result tuple. | # related operation transform and update result tuple. | ||||
| if flag & flags: | if flag & flags: | ||||
| vhash = True | vhash = True | ||||
| if flag not in _flagprocessors: | if flag not in _flagprocessors: | ||||
| message = _("missing processor for flag '%#x'") % (flag) | message = _("missing processor for flag '%#x'") % flag | ||||
| raise RevlogError(message) | raise RevlogError(message) | ||||
| processor = _flagprocessors[flag] | processor = _flagprocessors[flag] | ||||
| if processor is not None: | if processor is not None: | ||||
| readtransform, writetransform, rawtransform = processor | readtransform, writetransform, rawtransform = processor | ||||
| if raw: | if raw: | ||||
| vhash = rawtransform(self, text) | vhash = rawtransform(self, text) | ||||
| note: "addrevision" takes non-raw text, "_addrevision" takes raw text. | note: "addrevision" takes non-raw text, "_addrevision" takes raw text. | ||||
| invariants: | invariants: | ||||
| - rawtext is optional (can be None); if not set, cachedelta must be set. | - rawtext is optional (can be None); if not set, cachedelta must be set. | ||||
| if both are set, they must correspond to each other. | if both are set, they must correspond to each other. | ||||
| """ | """ | ||||
| if node == nullid: | if node == nullid: | ||||
| raise RevlogError(_("%s: attempt to add null revision") % | raise RevlogError(_("%s: attempt to add null revision") % | ||||
| (self.indexfile)) | self.indexfile) | ||||
| if node == wdirid: | if node == wdirid: | ||||
| raise RevlogError(_("%s: attempt to add wdir revision") % | raise RevlogError(_("%s: attempt to add wdir revision") % | ||||
| (self.indexfile)) | self.indexfile) | ||||
| btext = [rawtext] | btext = [rawtext] | ||||
| def buildtext(): | def buildtext(): | ||||
| if btext[0] is not None: | if btext[0] is not None: | ||||
| return btext[0] | return btext[0] | ||||
| baserev = cachedelta[0] | baserev = cachedelta[0] | ||||
| delta = cachedelta[1] | delta = cachedelta[1] | ||||
| # special case deltas which replace entire base; no need to decode | # special case deltas which replace entire base; no need to decode | ||||
| databytes += max(0, self.length(r)) | databytes += max(0, self.length(r)) | ||||
| dd = 0 | dd = 0 | ||||
| di = actual - len(self) * s - databytes | di = actual - len(self) * s - databytes | ||||
| except IOError as inst: | except IOError as inst: | ||||
| if inst.errno != errno.ENOENT: | if inst.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| di = 0 | di = 0 | ||||
| return (dd, di) | return dd, di | ||||
| def files(self): | def files(self): | ||||
| res = [self.indexfile] | res = [self.indexfile] | ||||
| if not self._inline: | if not self._inline: | ||||
| res.append(self.datafile) | res.append(self.datafile) | ||||
| return res | return res | ||||
| DELTAREUSEALWAYS = 'always' | DELTAREUSEALWAYS = 'always' | ||||
| # start actual discovery (we note this before the next "if" for | # start actual discovery (we note this before the next "if" for | ||||
| # compatibility reasons) | # compatibility reasons) | ||||
| ui.status(_("searching for changes\n")) | ui.status(_("searching for changes\n")) | ||||
| srvheads = dag.internalizeall(srvheadhashes, filterunknown=True) | srvheads = dag.internalizeall(srvheadhashes, filterunknown=True) | ||||
| if len(srvheads) == len(srvheadhashes): | if len(srvheads) == len(srvheadhashes): | ||||
| ui.debug("all remote heads known locally\n") | ui.debug("all remote heads known locally\n") | ||||
| return (srvheadhashes, False, srvheadhashes,) | return srvheadhashes, False, srvheadhashes, | ||||
| if sample and len(ownheads) <= initialsamplesize and all(yesno): | if sample and len(ownheads) <= initialsamplesize and all(yesno): | ||||
| ui.note(_("all local heads known remotely\n")) | ui.note(_("all local heads known remotely\n")) | ||||
| ownheadhashes = dag.externalizeall(ownheads) | ownheadhashes = dag.externalizeall(ownheads) | ||||
| return (ownheadhashes, True, srvheadhashes,) | return ownheadhashes, True, srvheadhashes, | ||||
| # full blown discovery | # full blown discovery | ||||
| # own nodes I know we both know | # own nodes I know we both know | ||||
| # treat remote heads (and maybe own heads) as a first implicit sample | # treat remote heads (and maybe own heads) as a first implicit sample | ||||
| # response | # response | ||||
| common = cl.incrementalmissingrevs(srvheads) | common = cl.incrementalmissingrevs(srvheads) | ||||
| commoninsample = set(n for i, n in enumerate(sample) if yesno[i]) | commoninsample = set(n for i, n in enumerate(sample) if yesno[i]) | ||||
| ui.log('discovery', msg, len(result), len(missing), roundtrips, | ui.log('discovery', msg, len(result), len(missing), roundtrips, | ||||
| elapsed) | elapsed) | ||||
| if not result and srvheadhashes != [nullid]: | if not result and srvheadhashes != [nullid]: | ||||
| if abortwhenunrelated: | if abortwhenunrelated: | ||||
| raise error.Abort(_("repository is unrelated")) | raise error.Abort(_("repository is unrelated")) | ||||
| else: | else: | ||||
| ui.warn(_("warning: repository is unrelated\n")) | ui.warn(_("warning: repository is unrelated\n")) | ||||
| return ({nullid}, True, srvheadhashes,) | return {nullid}, True, srvheadhashes, | ||||
| anyincoming = (srvheadhashes != [nullid]) | anyincoming = (srvheadhashes != [nullid]) | ||||
| return dag.externalizeall(result), anyincoming, srvheadhashes | return dag.externalizeall(result), anyincoming, srvheadhashes | ||||
| def _wait(self): | def _wait(self): | ||||
| """wait until some data are available on main or side | """wait until some data are available on main or side | ||||
| return a pair of boolean (ismainready, issideready) | return a pair of boolean (ismainready, issideready) | ||||
| (This will only wait for data if the setup is supported by `util.poll`) | (This will only wait for data if the setup is supported by `util.poll`) | ||||
| """ | """ | ||||
| if getattr(self._main, 'hasbuffer', False): # getattr for classic pipe | if getattr(self._main, 'hasbuffer', False): # getattr for classic pipe | ||||
| return (True, True) # main has data, assume side is worth poking at. | return True, True # main has data, assume side is worth poking at. | ||||
| fds = [self._main.fileno(), self._side.fileno()] | fds = [self._main.fileno(), self._side.fileno()] | ||||
| try: | try: | ||||
| act = util.poll(fds) | act = util.poll(fds) | ||||
| except NotImplementedError: | except NotImplementedError: | ||||
| # non supported yet case, assume all have data. | # non supported yet case, assume all have data. | ||||
| act = fds | act = fds | ||||
| return (self._main.fileno() in act, self._side.fileno() in act) | return self._main.fileno() in act, self._side.fileno() in act | ||||
| def write(self, data): | def write(self, data): | ||||
| return self._call('write', data) | return self._call('write', data) | ||||
| def read(self, size): | def read(self, size): | ||||
| r = self._call('read', size) | r = self._call('read', size) | ||||
| if size != 0 and not r: | if size != 0 and not r: | ||||
| # We've observed a condition that indicates the | # We've observed a condition that indicates the | ||||
| function[4].sort(reverse=True, key=lambda i: i.selfseconds()) | function[4].sort(reverse=True, key=lambda i: i.selfseconds()) | ||||
| for stat in function[4]: | for stat in function[4]: | ||||
| # only show line numbers for significant locations (>1% time spent) | # only show line numbers for significant locations (>1% time spent) | ||||
| if stat.selfpercent() > 1: | if stat.selfpercent() > 1: | ||||
| source = stat.site.getsource(25) | source = stat.site.getsource(25) | ||||
| stattuple = (stat.selfpercent(), stat.selfseconds(), | stattuple = (stat.selfpercent(), stat.selfseconds(), | ||||
| stat.site.lineno, source) | stat.site.lineno, source) | ||||
| print('%33.0f%% %6.2f line %s: %s' % (stattuple), file=fp) | print('%33.0f%% %6.2f line %s: %s' % stattuple, file=fp) | ||||
| def display_about_method(data, fp, function=None, **kwargs): | def display_about_method(data, fp, function=None, **kwargs): | ||||
| if function is None: | if function is None: | ||||
| raise Exception("Invalid function") | raise Exception("Invalid function") | ||||
| filename = None | filename = None | ||||
| if ':' in function: | if ':' in function: | ||||
| filename, function = function.split(':') | filename, function = function.split(':') | ||||
| def newcommitphase(ui, ctx): | def newcommitphase(ui, ctx): | ||||
| commitphase = phases.newcommitphase(ui) | commitphase = phases.newcommitphase(ui) | ||||
| substate = getattr(ctx, "substate", None) | substate = getattr(ctx, "substate", None) | ||||
| if not substate: | if not substate: | ||||
| return commitphase | return commitphase | ||||
| check = ui.config('phases', 'checksubrepos') | check = ui.config('phases', 'checksubrepos') | ||||
| if check not in ('ignore', 'follow', 'abort'): | if check not in ('ignore', 'follow', 'abort'): | ||||
| raise error.Abort(_('invalid phases.checksubrepos configuration: %s') | raise error.Abort(_('invalid phases.checksubrepos configuration: %s') | ||||
| % (check)) | % check) | ||||
| if check == 'ignore': | if check == 'ignore': | ||||
| return commitphase | return commitphase | ||||
| maxphase = phases.public | maxphase = phases.public | ||||
| maxsub = None | maxsub = None | ||||
| for s in sorted(substate): | for s in sorted(substate): | ||||
| sub = ctx.sub(s) | sub = ctx.sub(s) | ||||
| subphase = sub.phase(substate[s][1]) | subphase = sub.phase(substate[s][1]) | ||||
| if maxphase < subphase: | if maxphase < subphase: | ||||
| def walk(self, match): | def walk(self, match): | ||||
| ''' | ''' | ||||
| walk recursively through the directory tree, finding all files | walk recursively through the directory tree, finding all files | ||||
| matched by the match function | matched by the match function | ||||
| ''' | ''' | ||||
| def forget(self, match, prefix): | def forget(self, match, prefix): | ||||
| return ([], []) | return [], [] | ||||
| def removefiles(self, matcher, prefix, after, force, subrepos, warnings): | def removefiles(self, matcher, prefix, after, force, subrepos, warnings): | ||||
| """remove the matched files from the subrepository and the filesystem, | """remove the matched files from the subrepository and the filesystem, | ||||
| possibly by force and/or after the file has been removed from the | possibly by force and/or after the file has been removed from the | ||||
| filesystem. Return 0 on success, 1 on any warning. | filesystem. Return 0 on success, 1 on any warning. | ||||
| """ | """ | ||||
| warnings.append(_("warning: removefiles not implemented (%s)") | warnings.append(_("warning: removefiles not implemented (%s)") | ||||
| % self._path) | % self._path) | ||||
| return stdout, stderr | return stdout, stderr | ||||
| @propertycache | @propertycache | ||||
| def _svnversion(self): | def _svnversion(self): | ||||
| output, err = self._svncommand(['--version', '--quiet'], filename=None) | output, err = self._svncommand(['--version', '--quiet'], filename=None) | ||||
| m = re.search(br'^(\d+)\.(\d+)', output) | m = re.search(br'^(\d+)\.(\d+)', output) | ||||
| if not m: | if not m: | ||||
| raise error.Abort(_('cannot retrieve svn tool version')) | raise error.Abort(_('cannot retrieve svn tool version')) | ||||
| return (int(m.group(1)), int(m.group(2))) | return int(m.group(1)), int(m.group(2)) | ||||
| def _wcrevs(self): | def _wcrevs(self): | ||||
| # Get the working directory revision as well as the last | # Get the working directory revision as well as the last | ||||
| # commit revision so we can compare the subrepo state with | # commit revision so we can compare the subrepo state with | ||||
| # both. We used to store the working directory one. | # both. We used to store the working directory one. | ||||
| output, err = self._svncommand(['info', '--xml']) | output, err = self._svncommand(['info', '--xml']) | ||||
| doc = xml.dom.minidom.parseString(output) | doc = xml.dom.minidom.parseString(output) | ||||
| entries = doc.getElementsByTagName('entry') | entries = doc.getElementsByTagName('entry') | ||||
| lastrev, rev = '0', '0' | lastrev, rev = '0', '0' | ||||
| if entries: | if entries: | ||||
| rev = str(entries[0].getAttribute('revision')) or '0' | rev = str(entries[0].getAttribute('revision')) or '0' | ||||
| commits = entries[0].getElementsByTagName('commit') | commits = entries[0].getElementsByTagName('commit') | ||||
| if commits: | if commits: | ||||
| lastrev = str(commits[0].getAttribute('revision')) or '0' | lastrev = str(commits[0].getAttribute('revision')) or '0' | ||||
| return (lastrev, rev) | return lastrev, rev | ||||
| def _wcrev(self): | def _wcrev(self): | ||||
| return self._wcrevs()[0] | return self._wcrevs()[0] | ||||
| def _wcchanged(self): | def _wcchanged(self): | ||||
| """Return (changes, extchanges, missing) where changes is True | """Return (changes, extchanges, missing) where changes is True | ||||
| if the working directory was changed, extchanges is | if the working directory was changed, extchanges is | ||||
| True if any of these changes concern an external entry and missing | True if any of these changes concern an external entry and missing | ||||
| raise error.Abort(_('git subrepo requires at least 1.6.0 or later')) | raise error.Abort(_('git subrepo requires at least 1.6.0 or later')) | ||||
| elif versionstatus == 'warning': | elif versionstatus == 'warning': | ||||
| self.ui.warn(_('git subrepo requires at least 1.6.0 or later\n')) | self.ui.warn(_('git subrepo requires at least 1.6.0 or later\n')) | ||||
| @staticmethod | @staticmethod | ||||
| def _gitversion(out): | def _gitversion(out): | ||||
| m = re.search(br'^git version (\d+)\.(\d+)\.(\d+)', out) | m = re.search(br'^git version (\d+)\.(\d+)\.(\d+)', out) | ||||
| if m: | if m: | ||||
| return (int(m.group(1)), int(m.group(2)), int(m.group(3))) | return int(m.group(1)), int(m.group(2)), int(m.group(3)) | ||||
| m = re.search(br'^git version (\d+)\.(\d+)', out) | m = re.search(br'^git version (\d+)\.(\d+)', out) | ||||
| if m: | if m: | ||||
| return (int(m.group(1)), int(m.group(2)), 0) | return int(m.group(1)), int(m.group(2)), 0 | ||||
| return -1 | return -1 | ||||
| @staticmethod | @staticmethod | ||||
| def _checkversion(out): | def _checkversion(out): | ||||
| '''ensure git version is new enough | '''ensure git version is new enough | ||||
| >>> _checkversion = gitsubrepo._checkversion | >>> _checkversion = gitsubrepo._checkversion | ||||
| # (Unchanged tip trivially means no changesets have been added. | # (Unchanged tip trivially means no changesets have been added. | ||||
| # But, thanks to localrepository.destroyed(), it also means none | # But, thanks to localrepository.destroyed(), it also means none | ||||
| # have been destroyed by strip or rollback.) | # have been destroyed by strip or rollback.) | ||||
| if (cacherev == tiprev | if (cacherev == tiprev | ||||
| and cachenode == tipnode | and cachenode == tipnode | ||||
| and cachehash == scmutil.filteredhash(repo, tiprev)): | and cachehash == scmutil.filteredhash(repo, tiprev)): | ||||
| tags = _readtags(ui, repo, cachelines, cachefile.name) | tags = _readtags(ui, repo, cachelines, cachefile.name) | ||||
| cachefile.close() | cachefile.close() | ||||
| return (None, None, None, tags, False) | return None, None, None, tags, False | ||||
| if cachefile: | if cachefile: | ||||
| cachefile.close() # ignore rest of file | cachefile.close() # ignore rest of file | ||||
| valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev)) | valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev)) | ||||
| repoheads = repo.heads() | repoheads = repo.heads() | ||||
| # Case 2 (uncommon): empty repo; get out quickly and don't bother | # Case 2 (uncommon): empty repo; get out quickly and don't bother | ||||
| # writing an empty cache. | # writing an empty cache. | ||||
| if repoheads == [nullid]: | if repoheads == [nullid]: | ||||
| return ([], {}, valid, {}, False) | return [], {}, valid, {}, False | ||||
| # Case 3 (uncommon): cache file missing or empty. | # Case 3 (uncommon): cache file missing or empty. | ||||
| # Case 4 (uncommon): tip rev decreased. This should only happen | # Case 4 (uncommon): tip rev decreased. This should only happen | ||||
| # when we're called from localrepository.destroyed(). Refresh the | # when we're called from localrepository.destroyed(). Refresh the | ||||
| # cache so future invocations will not see disappeared heads in the | # cache so future invocations will not see disappeared heads in the | ||||
| # cache. | # cache. | ||||
| # Case 5 (common): tip has changed, so we've added/replaced heads. | # Case 5 (common): tip has changed, so we've added/replaced heads. | ||||
| # As it happens, the code to handle cases 3, 4, 5 is the same. | # As it happens, the code to handle cases 3, 4, 5 is the same. | ||||
| # N.B. in case 4 (nodes destroyed), "new head" really means "newly | # N.B. in case 4 (nodes destroyed), "new head" really means "newly | ||||
| # exposed". | # exposed". | ||||
| if not len(repo.file('.hgtags')): | if not len(repo.file('.hgtags')): | ||||
| # No tags have ever been committed, so we can avoid a | # No tags have ever been committed, so we can avoid a | ||||
| # potentially expensive search. | # potentially expensive search. | ||||
| return ([], {}, valid, None, True) | return [], {}, valid, None, True | ||||
| # Now we have to lookup the .hgtags filenode for every new head. | # Now we have to lookup the .hgtags filenode for every new head. | ||||
| # This is the most expensive part of finding tags, so performance | # This is the most expensive part of finding tags, so performance | ||||
| # depends primarily on the size of newheads. Worst case: no cache | # depends primarily on the size of newheads. Worst case: no cache | ||||
| # file, so newheads == repoheads. | # file, so newheads == repoheads. | ||||
| cachefnode = _getfnodes(ui, repo, repoheads) | cachefnode = _getfnodes(ui, repo, repoheads) | ||||
| # Caller has to iterate over all heads, but can use the filenodes in | # Caller has to iterate over all heads, but can use the filenodes in | ||||
| # cachefnode to get to each .hgtags revision quickly. | # cachefnode to get to each .hgtags revision quickly. | ||||
| return (repoheads, cachefnode, valid, None, True) | return repoheads, cachefnode, valid, None, True | ||||
| def _getfnodes(ui, repo, nodes): | def _getfnodes(ui, repo, nodes): | ||||
| """return .hgtags fnodes for a list of changeset nodes | """return .hgtags fnodes for a list of changeset nodes | ||||
| Return value is a {node: fnode} mapping. There will be no entry for nodes | Return value is a {node: fnode} mapping. There will be no entry for nodes | ||||
| without a '.hgtags' file. | without a '.hgtags' file. | ||||
| """ | """ | ||||
| starttime = util.timer() | starttime = util.timer() | ||||
| return | return | ||||
| repo = self._repo | repo = self._repo | ||||
| try: | try: | ||||
| lock = repo.wlock(wait=False) | lock = repo.wlock(wait=False) | ||||
| except error.LockError: | except error.LockError: | ||||
| repo.ui.log('tagscache', 'not writing .hg/cache/%s because ' | repo.ui.log('tagscache', 'not writing .hg/cache/%s because ' | ||||
| 'lock cannot be acquired\n' % (_fnodescachefile)) | 'lock cannot be acquired\n' % _fnodescachefile) | ||||
| return | return | ||||
| try: | try: | ||||
| f = repo.cachevfs.open(_fnodescachefile, 'ab') | f = repo.cachevfs.open(_fnodescachefile, 'ab') | ||||
| try: | try: | ||||
| # if the file has been truncated | # if the file has been truncated | ||||
| actualoffset = f.tell() | actualoffset = f.tell() | ||||
| if actualoffset < self._dirtyoffset: | if actualoffset < self._dirtyoffset: | ||||
| return tree | return tree | ||||
| op = tree[0] | op = tree[0] | ||||
| if op != 'template': | if op != 'template': | ||||
| return (op,) + tuple(_unnesttemplatelist(x) for x in tree[1:]) | return (op,) + tuple(_unnesttemplatelist(x) for x in tree[1:]) | ||||
| assert len(tree) == 2 | assert len(tree) == 2 | ||||
| xs = tuple(_unnesttemplatelist(x) for x in tree[1]) | xs = tuple(_unnesttemplatelist(x) for x in tree[1]) | ||||
| if not xs: | if not xs: | ||||
| return ('string', '') # empty template "" | return 'string', '' # empty template "" | ||||
| elif len(xs) == 1 and xs[0][0] == 'string': | elif len(xs) == 1 and xs[0][0] == 'string': | ||||
| return xs[0] # fast path for string with no template fragment "x" | return xs[0] # fast path for string with no template fragment "x" | ||||
| else: | else: | ||||
| return (op,) + xs | return (op,) + xs | ||||
| def parse(tmpl): | def parse(tmpl): | ||||
| """Parse template string into tree""" | """Parse template string into tree""" | ||||
| parsed, pos = _parsetemplate(tmpl, 0, len(tmpl)) | parsed, pos = _parsetemplate(tmpl, 0, len(tmpl)) | ||||
| except TemplateNotFound: | except TemplateNotFound: | ||||
| v = default | v = default | ||||
| if callable(v): | if callable(v): | ||||
| return v(**pycompat.strkwargs(mapping)) | return v(**pycompat.strkwargs(mapping)) | ||||
| return v | return v | ||||
| def buildtemplate(exp, context): | def buildtemplate(exp, context): | ||||
| ctmpl = [compileexp(e, context, methods) for e in exp[1:]] | ctmpl = [compileexp(e, context, methods) for e in exp[1:]] | ||||
| return (runtemplate, ctmpl) | return runtemplate, ctmpl | ||||
| def runtemplate(context, mapping, template): | def runtemplate(context, mapping, template): | ||||
| for arg in template: | for arg in template: | ||||
| yield evalrawexp(context, mapping, arg) | yield evalrawexp(context, mapping, arg) | ||||
| def buildfilter(exp, context): | def buildfilter(exp, context): | ||||
| n = getsymbol(exp[2]) | n = getsymbol(exp[2]) | ||||
| if n in context._filters: | if n in context._filters: | ||||
| filt = context._filters[n] | filt = context._filters[n] | ||||
| arg = compileexp(exp[1], context, methods) | arg = compileexp(exp[1], context, methods) | ||||
| return (runfilter, (arg, filt)) | return runfilter, (arg, filt) | ||||
| if n in funcs: | if n in funcs: | ||||
| f = funcs[n] | f = funcs[n] | ||||
| args = _buildfuncargs(exp[1], context, methods, n, f._argspec) | args = _buildfuncargs(exp[1], context, methods, n, f._argspec) | ||||
| return (f, args) | return f, args | ||||
| raise error.ParseError(_("unknown function '%s'") % n) | raise error.ParseError(_("unknown function '%s'") % n) | ||||
| def runfilter(context, mapping, data): | def runfilter(context, mapping, data): | ||||
| arg, filt = data | arg, filt = data | ||||
| thing = evalfuncarg(context, mapping, arg) | thing = evalfuncarg(context, mapping, arg) | ||||
| try: | try: | ||||
| return filt(thing) | return filt(thing) | ||||
| except (ValueError, AttributeError, TypeError): | except (ValueError, AttributeError, TypeError): | ||||
| sym = findsymbolicname(arg) | sym = findsymbolicname(arg) | ||||
| if sym: | if sym: | ||||
| msg = (_("template filter '%s' is not compatible with keyword '%s'") | msg = (_("template filter '%s' is not compatible with keyword '%s'") | ||||
| % (pycompat.sysbytes(filt.__name__), sym)) | % (pycompat.sysbytes(filt.__name__), sym)) | ||||
| else: | else: | ||||
| msg = (_("incompatible use of template filter '%s'") | msg = (_("incompatible use of template filter '%s'") | ||||
| % pycompat.sysbytes(filt.__name__)) | % pycompat.sysbytes(filt.__name__)) | ||||
| raise error.Abort(msg) | raise error.Abort(msg) | ||||
| def buildmap(exp, context): | def buildmap(exp, context): | ||||
| darg = compileexp(exp[1], context, methods) | darg = compileexp(exp[1], context, methods) | ||||
| targ = gettemplate(exp[2], context) | targ = gettemplate(exp[2], context) | ||||
| return (runmap, (darg, targ)) | return runmap, (darg, targ) | ||||
| def runmap(context, mapping, data): | def runmap(context, mapping, data): | ||||
| darg, targ = data | darg, targ = data | ||||
| d = evalrawexp(context, mapping, darg) | d = evalrawexp(context, mapping, darg) | ||||
| if util.safehasattr(d, 'itermaps'): | if util.safehasattr(d, 'itermaps'): | ||||
| diter = d.itermaps() | diter = d.itermaps() | ||||
| else: | else: | ||||
| try: | try: | ||||
| # v is not an iterable of dicts, this happen when 'key' | # v is not an iterable of dicts, this happen when 'key' | ||||
| # has been fully expanded already and format is useless. | # has been fully expanded already and format is useless. | ||||
| # If so, return the expanded value. | # If so, return the expanded value. | ||||
| yield v | yield v | ||||
| def buildmember(exp, context): | def buildmember(exp, context): | ||||
| darg = compileexp(exp[1], context, methods) | darg = compileexp(exp[1], context, methods) | ||||
| memb = getsymbol(exp[2]) | memb = getsymbol(exp[2]) | ||||
| return (runmember, (darg, memb)) | return runmember, (darg, memb) | ||||
| def runmember(context, mapping, data): | def runmember(context, mapping, data): | ||||
| darg, memb = data | darg, memb = data | ||||
| d = evalrawexp(context, mapping, darg) | d = evalrawexp(context, mapping, darg) | ||||
| if util.safehasattr(d, 'tomap'): | if util.safehasattr(d, 'tomap'): | ||||
| lm = mapping.copy() | lm = mapping.copy() | ||||
| lm.update(d.tomap()) | lm.update(d.tomap()) | ||||
| return runsymbol(context, lm, memb) | return runsymbol(context, lm, memb) | ||||
| if util.safehasattr(d, 'get'): | if util.safehasattr(d, 'get'): | ||||
| return _getdictitem(d, memb) | return _getdictitem(d, memb) | ||||
| sym = findsymbolicname(darg) | sym = findsymbolicname(darg) | ||||
| if sym: | if sym: | ||||
| raise error.ParseError(_("keyword '%s' has no member") % sym) | raise error.ParseError(_("keyword '%s' has no member") % sym) | ||||
| else: | else: | ||||
| raise error.ParseError(_("%r has no member") % d) | raise error.ParseError(_("%r has no member") % d) | ||||
| def buildnegate(exp, context): | def buildnegate(exp, context): | ||||
| arg = compileexp(exp[1], context, exprmethods) | arg = compileexp(exp[1], context, exprmethods) | ||||
| return (runnegate, arg) | return runnegate, arg | ||||
| def runnegate(context, mapping, data): | def runnegate(context, mapping, data): | ||||
| data = evalinteger(context, mapping, data, | data = evalinteger(context, mapping, data, | ||||
| _('negation needs an integer argument')) | _('negation needs an integer argument')) | ||||
| return -data | return -data | ||||
| def buildarithmetic(exp, context, func): | def buildarithmetic(exp, context, func): | ||||
| left = compileexp(exp[1], context, exprmethods) | left = compileexp(exp[1], context, exprmethods) | ||||
| right = compileexp(exp[2], context, exprmethods) | right = compileexp(exp[2], context, exprmethods) | ||||
| return (runarithmetic, (func, left, right)) | return runarithmetic, (func, left, right) | ||||
| def runarithmetic(context, mapping, data): | def runarithmetic(context, mapping, data): | ||||
| func, left, right = data | func, left, right = data | ||||
| left = evalinteger(context, mapping, left, | left = evalinteger(context, mapping, left, | ||||
| _('arithmetic only defined on integers')) | _('arithmetic only defined on integers')) | ||||
| right = evalinteger(context, mapping, right, | right = evalinteger(context, mapping, right, | ||||
| _('arithmetic only defined on integers')) | _('arithmetic only defined on integers')) | ||||
| try: | try: | ||||
| return func(left, right) | return func(left, right) | ||||
| except ZeroDivisionError: | except ZeroDivisionError: | ||||
| raise error.Abort(_('division by zero is not defined')) | raise error.Abort(_('division by zero is not defined')) | ||||
| def buildfunc(exp, context): | def buildfunc(exp, context): | ||||
| n = getsymbol(exp[1]) | n = getsymbol(exp[1]) | ||||
| if n in funcs: | if n in funcs: | ||||
| f = funcs[n] | f = funcs[n] | ||||
| args = _buildfuncargs(exp[2], context, exprmethods, n, f._argspec) | args = _buildfuncargs(exp[2], context, exprmethods, n, f._argspec) | ||||
| return (f, args) | return f, args | ||||
| if n in context._filters: | if n in context._filters: | ||||
| args = _buildfuncargs(exp[2], context, exprmethods, n, argspec=None) | args = _buildfuncargs(exp[2], context, exprmethods, n, argspec=None) | ||||
| if len(args) != 1: | if len(args) != 1: | ||||
| raise error.ParseError(_("filter %s expects one argument") % n) | raise error.ParseError(_("filter %s expects one argument") % n) | ||||
| f = context._filters[n] | f = context._filters[n] | ||||
| return (runfilter, (args[0], f)) | return runfilter, (args[0], f) | ||||
| raise error.ParseError(_("unknown function '%s'") % n) | raise error.ParseError(_("unknown function '%s'") % n) | ||||
| def _buildfuncargs(exp, context, curmethods, funcname, argspec): | def _buildfuncargs(exp, context, curmethods, funcname, argspec): | ||||
| """Compile parsed tree of function arguments into list or dict of | """Compile parsed tree of function arguments into list or dict of | ||||
| (func, data) pairs | (func, data) pairs | ||||
| >>> context = engine(lambda t: (runsymbol, t)) | >>> context = engine(lambda t: (runsymbol, t)) | ||||
| >>> def fargs(expr, argspec): | >>> def fargs(expr, argspec): | ||||
| if tzoffset is None: | if tzoffset is None: | ||||
| try: | try: | ||||
| tzoffset = int(tz) | tzoffset = int(tz) | ||||
| except (TypeError, ValueError): | except (TypeError, ValueError): | ||||
| # i18n: "localdate" is a keyword | # i18n: "localdate" is a keyword | ||||
| raise error.ParseError(_("localdate expects a timezone")) | raise error.ParseError(_("localdate expects a timezone")) | ||||
| else: | else: | ||||
| tzoffset = util.makedate()[1] | tzoffset = util.makedate()[1] | ||||
| return (date[0], tzoffset) | return date[0], tzoffset | ||||
| @templatefunc('max(iterable)') | @templatefunc('max(iterable)') | ||||
| def max_(context, mapping, args, **kwargs): | def max_(context, mapping, args, **kwargs): | ||||
| """Return the max of an iterable""" | """Return the max of an iterable""" | ||||
| if len(args) != 1: | if len(args) != 1: | ||||
| # i18n: "max" is a keyword | # i18n: "max" is a keyword | ||||
| raise error.ParseError(_("max expects one arguments")) | raise error.ParseError(_("max expects one arguments")) | ||||
| any = False | any = False | ||||
| for id, entry in sorted(self._filegenerators.iteritems()): | for id, entry in sorted(self._filegenerators.iteritems()): | ||||
| any = True | any = True | ||||
| order, filenames, genfunc, location = entry | order, filenames, genfunc, location = 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 | ||||
| postfinalize = group == gengrouppostfinalize | postfinalize = group == gengrouppostfinalize | ||||
| if (group != gengroupall and | if (group != gengroupall and | ||||
| (id in postfinalizegenerators) != (postfinalize)): | (id in postfinalizegenerators) != postfinalize): | ||||
| continue | continue | ||||
| vfs = self._vfsmap[location] | vfs = self._vfsmap[location] | ||||
| files = [] | files = [] | ||||
| try: | try: | ||||
| for name in filenames: | for name in filenames: | ||||
| name += suffix | name += suffix | ||||
| if suffix: | if suffix: | ||||
| This opens '.pending' of specified 'filename' only when HG_PENDING | This opens '.pending' of specified 'filename' only when HG_PENDING | ||||
| is equal to 'root'. | is equal to 'root'. | ||||
| This returns '(fp, is_pending_opened)' tuple. | This returns '(fp, is_pending_opened)' tuple. | ||||
| ''' | ''' | ||||
| if mayhavepending(root): | if mayhavepending(root): | ||||
| try: | try: | ||||
| return (vfs('%s.pending' % filename, **kwargs), True) | return vfs('%s.pending' % filename, **kwargs), True | ||||
| except IOError as inst: | except IOError as inst: | ||||
| if inst.errno != errno.ENOENT: | if inst.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| return (vfs(filename, **kwargs), False) | return vfs(filename, **kwargs), False | ||||
| # choices containing spaces, ASCII, or basically anything | # choices containing spaces, ASCII, or basically anything | ||||
| # except an ampersand followed by a character. | # except an ampersand followed by a character. | ||||
| m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt) | m = re.match(br'(?s)(.+?)\$\$([^\$]*&[^ \$].*)', prompt) | ||||
| msg = m.group(1) | msg = m.group(1) | ||||
| choices = [p.strip(' ') for p in m.group(2).split('$$')] | choices = [p.strip(' ') for p in m.group(2).split('$$')] | ||||
| def choicetuple(s): | def choicetuple(s): | ||||
| ampidx = s.index('&') | ampidx = s.index('&') | ||||
| return s[ampidx + 1:ampidx + 2].lower(), s.replace('&', '', 1) | return s[ampidx + 1:ampidx + 2].lower(), s.replace('&', '', 1) | ||||
| return (msg, [choicetuple(s) for s in choices]) | return msg, [choicetuple(s) for s in choices] | ||||
| def promptchoice(self, prompt, default=0): | def promptchoice(self, prompt, default=0): | ||||
| """Prompt user with a message, read response, and ensure it matches | """Prompt user with a message, read response, and ensure it matches | ||||
| one of the provided choices. The prompt is formatted as follows: | one of the provided choices. The prompt is formatted as follows: | ||||
| "would you like fries with that (Yn)? $$ &Yes $$ &No" | "would you like fries with that (Yn)? $$ &Yes $$ &No" | ||||
| The index of the choice is returned. Responses are case | The index of the choice is returned. Responses are case | ||||
| def add_password(self, realm, uri, user, passwd): | def add_password(self, realm, uri, user, passwd): | ||||
| return self.passwddb.add_password(realm, uri, user, passwd) | return self.passwddb.add_password(realm, uri, user, passwd) | ||||
| def find_user_password(self, realm, authuri): | def find_user_password(self, realm, authuri): | ||||
| authinfo = self.passwddb.find_user_password(realm, authuri) | authinfo = self.passwddb.find_user_password(realm, authuri) | ||||
| user, passwd = authinfo | user, passwd = authinfo | ||||
| if user and passwd: | if user and passwd: | ||||
| self._writedebug(user, passwd) | self._writedebug(user, passwd) | ||||
| return (user, passwd) | return user, passwd | ||||
| if not user or not passwd: | if not user or not passwd: | ||||
| res = httpconnectionmod.readauthforuri(self.ui, authuri, user) | res = httpconnectionmod.readauthforuri(self.ui, authuri, user) | ||||
| if res: | if res: | ||||
| group, auth = res | group, auth = res | ||||
| user, passwd = auth.get('username'), auth.get('password') | user, passwd = auth.get('username'), auth.get('password') | ||||
| self.ui.debug("using auth.%s.* for authentication\n" % group) | self.ui.debug("using auth.%s.* for authentication\n" % group) | ||||
| if not user or not passwd: | if not user or not passwd: | ||||
| else: | else: | ||||
| user = self.ui.prompt(_("user:"), default=None) | user = self.ui.prompt(_("user:"), default=None) | ||||
| if not passwd: | if not passwd: | ||||
| passwd = self.ui.getpass() | passwd = self.ui.getpass() | ||||
| self.passwddb.add_password(realm, authuri, user, passwd) | self.passwddb.add_password(realm, authuri, user, passwd) | ||||
| self._writedebug(user, passwd) | self._writedebug(user, passwd) | ||||
| return (user, passwd) | return user, passwd | ||||
| def _writedebug(self, user, passwd): | def _writedebug(self, user, passwd): | ||||
| msg = _('http auth: user %s, password %s\n') | msg = _('http auth: user %s, password %s\n') | ||||
| self.ui.debug(msg % (user, passwd and '*' * len(passwd) or 'not set')) | self.ui.debug(msg % (user, passwd and '*' * len(passwd) or 'not set')) | ||||
| def find_stored_password(self, authuri): | def find_stored_password(self, authuri): | ||||
| return self.passwddb.find_user_password(None, authuri) | return self.passwddb.find_user_password(None, authuri) | ||||
| vints.append(int(i)) | vints.append(int(i)) | ||||
| except ValueError: | except ValueError: | ||||
| break | break | ||||
| # (3, 6) -> (3, 6, None) | # (3, 6) -> (3, 6, None) | ||||
| while len(vints) < 3: | while len(vints) < 3: | ||||
| vints.append(None) | vints.append(None) | ||||
| if n == 2: | if n == 2: | ||||
| return (vints[0], vints[1]) | return vints[0], vints[1] | ||||
| if n == 3: | if n == 3: | ||||
| return (vints[0], vints[1], vints[2]) | return vints[0], vints[1], vints[2] | ||||
| if n == 4: | if n == 4: | ||||
| return (vints[0], vints[1], vints[2], extra) | return vints[0], vints[1], vints[2], extra | ||||
| # used by parsedate | # used by parsedate | ||||
| defaultdateformats = ( | defaultdateformats = ( | ||||
| '%Y-%m-%dT%H:%M:%S', # the 'real' ISO8601 | '%Y-%m-%dT%H:%M:%S', # the 'real' ISO8601 | ||||
| '%Y-%m-%dT%H:%M', # without seconds | '%Y-%m-%dT%H:%M', # without seconds | ||||
| '%Y-%m-%dT%H%M%S', # another awful but legal variant without : | '%Y-%m-%dT%H%M%S', # another awful but legal variant without : | ||||
| '%Y-%m-%dT%H%M', # without seconds | '%Y-%m-%dT%H%M', # without seconds | ||||
| '%Y-%m-%d %H:%M:%S', # our common legal variant | '%Y-%m-%d %H:%M:%S', # our common legal variant | ||||
| Therefore, all "S[n-1].ctime == S[n].ctime" cases should be | Therefore, all "S[n-1].ctime == S[n].ctime" cases should be | ||||
| treated as ambiguous regardless of mtime, to avoid overlooking | treated as ambiguous regardless of mtime, to avoid overlooking | ||||
| by confliction between such mtime. | by confliction between such mtime. | ||||
| Advancing mtime "if isambig(oldstat)" ensures "S[n-1].mtime != | Advancing mtime "if isambig(oldstat)" ensures "S[n-1].mtime != | ||||
| S[n].mtime", even if size of a file isn't changed. | S[n].mtime", even if size of a file isn't changed. | ||||
| """ | """ | ||||
| try: | try: | ||||
| return (self.stat.st_ctime == old.stat.st_ctime) | return self.stat.st_ctime == old.stat.st_ctime | ||||
| except AttributeError: | except AttributeError: | ||||
| return False | return False | ||||
| def avoidambig(self, path, old): | def avoidambig(self, path, old): | ||||
| """Change file stat of specified path to avoid ambiguity | """Change file stat of specified path to avoid ambiguity | ||||
| 'old' should be previous filestat of 'path'. | 'old' should be previous filestat of 'path'. | ||||
| This requires use decision to determine width of such characters. | This requires use decision to determine width of such characters. | ||||
| """ | """ | ||||
| def _cutdown(self, ucstr, space_left): | def _cutdown(self, ucstr, space_left): | ||||
| l = 0 | l = 0 | ||||
| colwidth = encoding.ucolwidth | colwidth = encoding.ucolwidth | ||||
| for i in xrange(len(ucstr)): | for i in xrange(len(ucstr)): | ||||
| l += colwidth(ucstr[i]) | l += colwidth(ucstr[i]) | ||||
| if space_left < l: | if space_left < l: | ||||
| return (ucstr[:i], ucstr[i:]) | return ucstr[:i], ucstr[i:] | ||||
| return ucstr, '' | return ucstr, '' | ||||
| # overriding of base class | # overriding of base class | ||||
| def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width): | def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width): | ||||
| space_left = max(width - cur_len, 1) | space_left = max(width - cur_len, 1) | ||||
| if self.break_long_words: | if self.break_long_words: | ||||
| cut, res = self._cutdown(reversed_chunks[-1], space_left) | cut, res = self._cutdown(reversed_chunks[-1], space_left) | ||||
| def authinfo(self): | def authinfo(self): | ||||
| user, passwd = self.user, self.passwd | user, passwd = self.user, self.passwd | ||||
| try: | try: | ||||
| self.user, self.passwd = None, None | self.user, self.passwd = None, None | ||||
| s = bytes(self) | s = bytes(self) | ||||
| finally: | finally: | ||||
| self.user, self.passwd = user, passwd | self.user, self.passwd = user, passwd | ||||
| if not self.user: | if not self.user: | ||||
| return (s, None) | return s, None | ||||
| # authinfo[1] is passed to urllib2 password manager, and its | # authinfo[1] is passed to urllib2 password manager, and its | ||||
| # URIs must not contain credentials. The host is passed in the | # URIs must not contain credentials. The host is passed in the | ||||
| # URIs list because Python < 2.4.3 uses only that to search for | # URIs list because Python < 2.4.3 uses only that to search for | ||||
| # a password. | # a password. | ||||
| return (s, (None, (s, self.host), | return (s, (None, (s, self.host), | ||||
| self.user, self.passwd or '')) | self.user, self.passwd or '')) | ||||
| def isabs(self): | def isabs(self): | ||||
| "use getint() instead of ui.configint() for early Mercurial"), | "use getint() instead of ui.configint() for early Mercurial"), | ||||
| ], | ], | ||||
| # warnings | # warnings | ||||
| [ | [ | ||||
| ] | ] | ||||
| ] | ] | ||||
| def modulewhitelist(names): | def modulewhitelist(names): | ||||
| replacement = [('.py', ''), ('.c', ''), # trim suffix | replacement = [('.py', ''), ('.c', ''), # trim suffix | ||||
| ('mercurial%s' % (os.sep), ''), # trim "mercurial/" path | ('mercurial%s' % os.sep, ''), # trim "mercurial/" path | ||||
| ] | ] | ||||
| ignored = {'__init__'} | ignored = {'__init__'} | ||||
| modules = {} | modules = {} | ||||
| # convert from file name to module name, and count # of appearances | # convert from file name to module name, and count # of appearances | ||||
| for name in names: | for name in names: | ||||
| name = name.strip() | name = name.strip() | ||||
| for old, new in replacement: | for old, new in replacement: | ||||
| name = name.replace(old, new) | name = name.replace(old, new) | ||||
| def validatehash(self, text): | def validatehash(self, text): | ||||
| return True | return True | ||||
| def bypass(self, text): | def bypass(self, text): | ||||
| return False | return False | ||||
| def noopdonothing(self, text): | def noopdonothing(self, text): | ||||
| return (text, True) | return text, True | ||||
| def b64encode(self, text): | def b64encode(self, text): | ||||
| return (base64.b64encode(text), False) | return base64.b64encode(text), False | ||||
| def b64decode(self, text): | def b64decode(self, text): | ||||
| return (base64.b64decode(text), True) | return base64.b64decode(text), True | ||||
| def gzipcompress(self, text): | def gzipcompress(self, text): | ||||
| return (zlib.compress(text), False) | return zlib.compress(text), False | ||||
| def gzipdecompress(self, text): | def gzipdecompress(self, text): | ||||
| return (zlib.decompress(text), True) | return zlib.decompress(text), True | ||||
| def supportedoutgoingversions(orig, repo): | def supportedoutgoingversions(orig, repo): | ||||
| versions = orig(repo) | versions = orig(repo) | ||||
| versions.discard('01') | versions.discard('01') | ||||
| versions.discard('02') | versions.discard('02') | ||||
| versions.add('03') | versions.add('03') | ||||
| return versions | return versions | ||||
| _lsprof.Profiler # silence unused import warning | _lsprof.Profiler # silence unused import warning | ||||
| return True | return True | ||||
| except ImportError: | except ImportError: | ||||
| return False | return False | ||||
| def gethgversion(): | def gethgversion(): | ||||
| m = matchoutput('hg --version --quiet 2>&1', br'(\d+)\.(\d+)') | m = matchoutput('hg --version --quiet 2>&1', br'(\d+)\.(\d+)') | ||||
| if not m: | if not m: | ||||
| return (0, 0) | return 0, 0 | ||||
| return (int(m.group(1)), int(m.group(2))) | return int(m.group(1)), int(m.group(2)) | ||||
| @checkvers("hg", "Mercurial >= %s", | @checkvers("hg", "Mercurial >= %s", | ||||
| list([(1.0 * x) / 10 for x in range(9, 99)])) | list([(1.0 * x) / 10 for x in range(9, 99)])) | ||||
| def has_hg_range(v): | def has_hg_range(v): | ||||
| major, minor = v.split('.')[0:2] | major, minor = v.split('.')[0:2] | ||||
| return gethgversion() >= (int(major), int(minor)) | return gethgversion() >= (int(major), int(minor)) | ||||
| @check("hg08", "Mercurial >= 0.8") | @check("hg08", "Mercurial >= 0.8") | ||||
| @check("git", "git command line client") | @check("git", "git command line client") | ||||
| def has_git(): | def has_git(): | ||||
| return matchoutput('git --version 2>&1', br'^git version') | return matchoutput('git --version 2>&1', br'^git version') | ||||
| def getgitversion(): | def getgitversion(): | ||||
| m = matchoutput('git --version 2>&1', br'git version (\d+)\.(\d+)') | m = matchoutput('git --version 2>&1', br'git version (\d+)\.(\d+)') | ||||
| if not m: | if not m: | ||||
| return (0, 0) | return 0, 0 | ||||
| return (int(m.group(1)), int(m.group(2))) | return int(m.group(1)), int(m.group(2)) | ||||
| @checkvers("git", "git client (with ext::sh support) version >= %s", (1.9,)) | @checkvers("git", "git client (with ext::sh support) version >= %s", (1.9,)) | ||||
| def has_git_range(v): | def has_git_range(v): | ||||
| major, minor = v.split('.')[0:2] | major, minor = v.split('.')[0:2] | ||||
| return getgitversion() >= (int(major), int(minor)) | return getgitversion() >= (int(major), int(minor)) | ||||
| @check("docutils", "Docutils text processing library") | @check("docutils", "Docutils text processing library") | ||||
| def has_docutils(): | def has_docutils(): | ||||
| try: | try: | ||||
| import docutils.core | import docutils.core | ||||
| docutils.core.publish_cmdline # silence unused import | docutils.core.publish_cmdline # silence unused import | ||||
| return True | return True | ||||
| except ImportError: | except ImportError: | ||||
| return False | return False | ||||
| def getsvnversion(): | def getsvnversion(): | ||||
| m = matchoutput('svn --version --quiet 2>&1', br'^(\d+)\.(\d+)') | m = matchoutput('svn --version --quiet 2>&1', br'^(\d+)\.(\d+)') | ||||
| if not m: | if not m: | ||||
| return (0, 0) | return 0, 0 | ||||
| return (int(m.group(1)), int(m.group(2))) | return int(m.group(1)), int(m.group(2)) | ||||
| @checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5)) | @checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5)) | ||||
| def has_svn_range(v): | def has_svn_range(v): | ||||
| major, minor = v.split('.')[0:2] | major, minor = v.split('.')[0:2] | ||||
| return getsvnversion() >= (int(major), int(minor)) | return getsvnversion() >= (int(major), int(minor)) | ||||
| @check("svn", "subversion client and admin tools") | @check("svn", "subversion client and admin tools") | ||||
| def has_svn(): | def has_svn(): | ||||
| def has_debdeps(): | def has_debdeps(): | ||||
| # just check exit status (ignoring output) | # just check exit status (ignoring output) | ||||
| path = '%s/../contrib/debian/control' % os.environ['TESTDIR'] | path = '%s/../contrib/debian/control' % os.environ['TESTDIR'] | ||||
| return matchoutput('dpkg-checkbuilddeps %s' % path, br'') | return matchoutput('dpkg-checkbuilddeps %s' % path, br'') | ||||
| @check("demandimport", "demandimport enabled") | @check("demandimport", "demandimport enabled") | ||||
| def has_demandimport(): | def has_demandimport(): | ||||
| # chg disables demandimport intentionally for performance wins. | # chg disables demandimport intentionally for performance wins. | ||||
| return ((not has_chg()) and os.environ.get('HGDEMANDIMPORT') != 'disable') | return (not has_chg()) and os.environ.get('HGDEMANDIMPORT') != 'disable' | ||||
| @check("py3k", "running with Python 3.x") | @check("py3k", "running with Python 3.x") | ||||
| def has_py3k(): | def has_py3k(): | ||||
| return 3 == sys.version_info[0] | return 3 == sys.version_info[0] | ||||
| @check("py3exe", "a Python 3.x interpreter is available") | @check("py3exe", "a Python 3.x interpreter is available") | ||||
| def has_python3exe(): | def has_python3exe(): | ||||
| return 'PYTHON3' in os.environ | return 'PYTHON3' in os.environ | ||||
| if options.whitelist: | if options.whitelist: | ||||
| options.whitelisted = parselistfiles(options.whitelist, 'whitelist') | options.whitelisted = parselistfiles(options.whitelist, 'whitelist') | ||||
| else: | else: | ||||
| options.whitelisted = {} | options.whitelisted = {} | ||||
| if options.showchannels: | if options.showchannels: | ||||
| options.nodiff = True | options.nodiff = True | ||||
| return (options, args) | return options, args | ||||
| def rename(src, dst): | def rename(src, dst): | ||||
| """Like os.rename(), trade atomicity and opened files friendliness | """Like os.rename(), trade atomicity and opened files friendliness | ||||
| for existing destination support. | for existing destination support. | ||||
| """ | """ | ||||
| shutil.copy(src, dst) | shutil.copy(src, dst) | ||||
| os.remove(src) | os.remove(src) | ||||
| raise unittest.SkipTest('unknown test type') | raise unittest.SkipTest('unknown test type') | ||||
| def abort(self): | def abort(self): | ||||
| """Terminate execution of this test.""" | """Terminate execution of this test.""" | ||||
| self._aborted = True | self._aborted = True | ||||
| def _portmap(self, i): | def _portmap(self, i): | ||||
| offset = b'' if i == 0 else b'%d' % i | offset = b'' if i == 0 else b'%d' % i | ||||
| return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset) | return br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset | ||||
| def _getreplacements(self): | def _getreplacements(self): | ||||
| """Obtain a mapping of text replacements to apply to test output. | """Obtain a mapping of text replacements to apply to test output. | ||||
| Test output needs to be normalized so it can be compared to expected | Test output needs to be normalized so it can be compared to expected | ||||
| output. This function defines how some of that normalization will | output. This function defines how some of that normalization will | ||||
| occur. | occur. | ||||
| """ | """ | ||||
| stderr). | stderr). | ||||
| Return a tuple (exitcode, output). output is None in debug mode. | Return a tuple (exitcode, output). output is None in debug mode. | ||||
| """ | """ | ||||
| if self._debug: | if self._debug: | ||||
| proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp, | proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp, | ||||
| env=env) | env=env) | ||||
| ret = proc.wait() | ret = proc.wait() | ||||
| return (ret, None) | return ret, None | ||||
| proc = Popen4(cmd, self._testtmp, self._timeout, env) | proc = Popen4(cmd, self._testtmp, self._timeout, env) | ||||
| def cleanup(): | def cleanup(): | ||||
| terminate(proc) | terminate(proc) | ||||
| ret = proc.wait() | ret = proc.wait() | ||||
| if ret == 0: | if ret == 0: | ||||
| ret = signal.SIGTERM << 8 | ret = signal.SIGTERM << 8 | ||||
| killdaemons(env['DAEMON_PIDS']) | killdaemons(env['DAEMON_PIDS']) | ||||
Why this extra indentation?