| hg-reviewers |
This is a little less brittle, and often helps indentation. In a
surprising number of cases the entire cleanup was deleting the \, as
the expression was *already* parenthesized in a workable way.
| Lint Skipped |
| Unit Tests Skipped |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| Augie Fackler | Feb 20 2019, 7:28 PM |
| cl = repo.changelog | cl = repo.changelog | ||||
| mf = repo.manifestlog | mf = repo.manifestlog | ||||
| cl, mf # use variables to appease pyflakes | cl, mf # use variables to appease pyflakes | ||||
| IPython.embed() | IPython.embed() | ||||
| @command('debugshell|dbsh', []) | @command('debugshell|dbsh', []) | ||||
| def debugshell(ui, repo, **opts): | def debugshell(ui, repo, **opts): | ||||
| bannermsg = "loaded repo : %s\n" \ | bannermsg = ("loaded repo : %s\n" | ||||
| "using source: %s" % (repo.root, | "using source: %s" % (repo.root, | ||||
| mercurial.__path__[0]) | mercurial.__path__[0])) | ||||
| pdbmap = { | pdbmap = { | ||||
| 'pdb' : 'code', | 'pdb' : 'code', | ||||
| 'ipdb' : 'IPython' | 'ipdb' : 'IPython' | ||||
| } | } | ||||
| debugger = ui.config("ui", "debugger") | debugger = ui.config("ui", "debugger") | ||||
| if not debugger: | if not debugger: | ||||
| '-', | '-', | ||||
| ] | ] | ||||
| print('executing: %r' % args) | print('executing: %r' % args) | ||||
| p = subprocess.Popen(args, stdin=subprocess.PIPE) | p = subprocess.Popen(args, stdin=subprocess.PIPE) | ||||
| p.communicate(input=dockerfile) | p.communicate(input=dockerfile) | ||||
| if p.returncode: | if p.returncode: | ||||
| raise subprocess.CalledProcessException( | raise subprocess.CalledProcessException( | ||||
| p.returncode, 'failed to build docker image: %s %s' \ | p.returncode, 'failed to build docker image: %s %s' | ||||
| % (p.stdout, p.stderr)) | % (p.stdout, p.stderr)) | ||||
| def command_build(args): | def command_build(args): | ||||
| build_args = [] | build_args = [] | ||||
| for arg in args.build_arg: | for arg in args.build_arg: | ||||
| k, v = arg.split('=', 1) | k, v = arg.split('=', 1) | ||||
| build_args.append((k.encode('utf-8'), v.encode('utf-8'))) | build_args.append((k.encode('utf-8'), v.encode('utf-8'))) | ||||
| for ug in usersorgroups.replace(',', ' ').split(): | for ug in usersorgroups.replace(',', ' ').split(): | ||||
| if ug.startswith('!'): | if ug.startswith('!'): | ||||
| # Test for excluded user or group. Format: | # Test for excluded user or group. Format: | ||||
| # if ug is a user name: !username | # if ug is a user name: !username | ||||
| # if ug is a group name: !@groupname | # if ug is a group name: !@groupname | ||||
| ug = ug[1:] | ug = ug[1:] | ||||
| if not ug.startswith('@') and user != ug \ | if (not ug.startswith('@') and user != ug | ||||
| or ug.startswith('@') and user not in _getusers(ui, ug[1:]): | or ug.startswith('@') and user not in _getusers(ui, ug[1:])): | ||||
| return True | return True | ||||
| # Test for user or group. Format: | # Test for user or group. Format: | ||||
| # if ug is a user name: username | # if ug is a user name: username | ||||
| # if ug is a group name: @groupname | # if ug is a group name: @groupname | ||||
| elif user == ug \ | elif (user == ug | ||||
| or ug.startswith('@') and user in _getusers(ui, ug[1:]): | or ug.startswith('@') and user in _getusers(ui, ug[1:])): | ||||
| return True | return True | ||||
| return False | return False | ||||
| def buildmatch(ui, repo, user, key): | def buildmatch(ui, repo, user, key): | ||||
| '''return tuple of (match function, list enabled).''' | '''return tuple of (match function, list enabled).''' | ||||
| if not ui.has_section(key): | if not ui.has_section(key): | ||||
| ui.debug('acl: %s not enabled\n' % key) | ui.debug('acl: %s not enabled\n' % key) | ||||
| (bugid, userid, now, self.longdesc_id)) | (bugid, userid, now, self.longdesc_id)) | ||||
| self.conn.commit() | self.conn.commit() | ||||
| class bzmysql_2_18(bzmysql): | class bzmysql_2_18(bzmysql): | ||||
| '''support for bugzilla 2.18 series.''' | '''support for bugzilla 2.18 series.''' | ||||
| def __init__(self, ui): | def __init__(self, ui): | ||||
| bzmysql.__init__(self, ui) | bzmysql.__init__(self, ui) | ||||
| self.default_notify = \ | self.default_notify = ( | ||||
| "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s" | "cd %(bzdir)s && perl -T contrib/sendbugmail.pl %(id)s %(user)s") | ||||
| class bzmysql_3_0(bzmysql_2_18): | class bzmysql_3_0(bzmysql_2_18): | ||||
| '''support for bugzilla 3.0 series.''' | '''support for bugzilla 3.0 series.''' | ||||
| def __init__(self, ui): | def __init__(self, ui): | ||||
| bzmysql_2_18.__init__(self, ui) | bzmysql_2_18.__init__(self, ui) | ||||
| def get_longdesc_id(self): | def get_longdesc_id(self): | ||||
| p = candidate | p = candidate | ||||
| c.parents = [] | c.parents = [] | ||||
| if p is not None: | if p is not None: | ||||
| p = changesets[p] | p = changesets[p] | ||||
| # Ensure no changeset has a synthetic changeset as a parent. | # Ensure no changeset has a synthetic changeset as a parent. | ||||
| while p.synthetic: | while p.synthetic: | ||||
| assert len(p.parents) <= 1, \ | assert len(p.parents) <= 1, ( | ||||
| _('synthetic changeset cannot have multiple parents') | _('synthetic changeset cannot have multiple parents')) | ||||
| if p.parents: | if p.parents: | ||||
| p = p.parents[0] | p = p.parents[0] | ||||
| else: | else: | ||||
| p = None | p = None | ||||
| break | break | ||||
| if p is not None: | if p is not None: | ||||
| c.parents.append(p) | c.parents.append(p) | ||||
| fn, | fn, | ||||
| '.'.join([b"%d" % x for x in f.parent]) or 'INITIAL', | '.'.join([b"%d" % x for x in f.parent]) or 'INITIAL', | ||||
| '.'.join([(b"%d" % x) for x in f.revision]), | '.'.join([(b"%d" % x) for x in f.revision]), | ||||
| ['', '(DEAD)'][f.dead])) | ['', '(DEAD)'][f.dead])) | ||||
| ui.write('\n') | ui.write('\n') | ||||
| # have we seen the start tag? | # have we seen the start tag? | ||||
| if revisions and off: | if revisions and off: | ||||
| if revisions[0] == (b"%d" % cs.id) or \ | if (revisions[0] == (b"%d" % cs.id) or | ||||
| revisions[0] in cs.tags: | revisions[0] in cs.tags): | ||||
| off = False | off = False | ||||
| # see if we reached the end tag | # see if we reached the end tag | ||||
| if len(revisions) > 1 and not off: | if len(revisions) > 1 and not off: | ||||
| if revisions[1] == (b"%d" % cs.id) or \ | if (revisions[1] == (b"%d" % cs.id) or | ||||
| revisions[1] in cs.tags: | revisions[1] in cs.tags): | ||||
| break | break | ||||
| rev=version, | rev=version, | ||||
| extra=extra, | extra=extra, | ||||
| saverev=saverev) | saverev=saverev) | ||||
| return c | return c | ||||
| def numcommits(self): | def numcommits(self): | ||||
| output, ret = self.gitrunlines('rev-list', '--all') | output, ret = self.gitrunlines('rev-list', '--all') | ||||
| if ret: | if ret: | ||||
| raise error.Abort(_('cannot retrieve number of commits in %s') \ | raise error.Abort(_('cannot retrieve number of commits in %s') | ||||
| % self.path) | % self.path) | ||||
| return len(output) | return len(output) | ||||
| def gettags(self): | def gettags(self): | ||||
| tags = {} | tags = {} | ||||
| alltags = {} | alltags = {} | ||||
| output, status = self.gitrunlines('ls-remote', '--tags', self.path) | output, status = self.gitrunlines('ls-remote', '--tags', self.path) | ||||
| 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] | ||||
| flcmd = 'p4 -G filelog %s' \ | flcmd = ('p4 -G filelog %s' | ||||
| % procutil.shellquote(oldname) | % procutil.shellquote(oldname)) | ||||
| flstdout = procutil.popen(flcmd, mode='rb') | flstdout = procutil.popen(flcmd, mode='rb') | ||||
| copiedfilename = None | copiedfilename = None | ||||
| for d in loaditer(flstdout): | for d in loaditer(flstdout): | ||||
| copiedoldname = None | copiedoldname = None | ||||
| i = 0 | i = 0 | ||||
| while ("change%d" % i) in d: | while ("change%d" % i) in d: | ||||
| @util.propertycache | @util.propertycache | ||||
| def depotname(self): | def depotname(self): | ||||
| return self._parse_once['depotname'] | return self._parse_once['depotname'] | ||||
| def getheads(self): | def getheads(self): | ||||
| return self.heads | return self.heads | ||||
| def getfile(self, name, rev): | def getfile(self, name, rev): | ||||
| cmd = 'p4 -G print %s' \ | cmd = ('p4 -G print %s' | ||||
| % procutil.shellquote("%s#%s" % (self.depotname[name], rev)) | % procutil.shellquote("%s#%s" % (self.depotname[name], rev))) | ||||
| lasterror = None | lasterror = None | ||||
| while True: | while True: | ||||
| stdout = procutil.popen(cmd, mode='rb') | stdout = procutil.popen(cmd, mode='rb') | ||||
| mode = None | mode = None | ||||
| contents = [] | contents = [] | ||||
| keywords = None | keywords = None | ||||
| nroot = path.strip('/') | nroot = path.strip('/') | ||||
| children = self._iterfiles(oroot, prevnum) | children = self._iterfiles(oroot, prevnum) | ||||
| for childpath in children: | for childpath in children: | ||||
| childpath = childpath.replace(oroot, nroot) | childpath = childpath.replace(oroot, nroot) | ||||
| childpath = self.getrelpath("/" + childpath, pmodule) | childpath = self.getrelpath("/" + childpath, pmodule) | ||||
| if childpath: | if childpath: | ||||
| removed.add(self.recode(childpath)) | removed.add(self.recode(childpath)) | ||||
| else: | else: | ||||
| self.ui.debug('unknown path in revision %d: %s\n' % \ | self.ui.debug('unknown path in revision %d: %s\n' % | ||||
| (revnum, path)) | (revnum, path)) | ||||
| elif kind == svn.core.svn_node_dir: | elif kind == svn.core.svn_node_dir: | ||||
| if ent.action == 'M': | if ent.action == 'M': | ||||
| # If the directory just had a prop change, | # If the directory just had a prop change, | ||||
| # then we shouldn't need to look for its children. | # then we shouldn't need to look for its children. | ||||
| continue | continue | ||||
| if ent.action == 'R' and parents: | if ent.action == 'R' and parents: | ||||
| # If a directory is replacing a file, mark the previous | # If a directory is replacing a file, mark the previous | ||||
| tr = repo.transaction('histedit') | tr = repo.transaction('histedit') | ||||
| progress = ui.makeprogress(_("editing"), unit=_('changes'), | progress = ui.makeprogress(_("editing"), unit=_('changes'), | ||||
| total=len(state.actions)) | total=len(state.actions)) | ||||
| with progress, util.acceptintervention(tr): | with progress, util.acceptintervention(tr): | ||||
| while state.actions: | while state.actions: | ||||
| state.write(tr=tr) | state.write(tr=tr) | ||||
| actobj = state.actions[0] | actobj = state.actions[0] | ||||
| progress.increment(item=actobj.torule()) | progress.increment(item=actobj.torule()) | ||||
| ui.debug('histedit: processing %s %s\n' % (actobj.verb,\ | ui.debug('histedit: processing %s %s\n' % (actobj.verb, | ||||
| actobj.torule())) | actobj.torule())) | ||||
| parentctx, replacement_ = actobj.run() | parentctx, replacement_ = actobj.run() | ||||
| state.parentctxnode = parentctx.node() | state.parentctxnode = parentctx.node() | ||||
| state.replacements.extend(replacement_) | state.replacements.extend(replacement_) | ||||
| state.actions.pop(0) | state.actions.pop(0) | ||||
| state.write() | state.write() | ||||
| if not rules: | if not rules: | ||||
| comment = geteditcomment(ui, | comment = geteditcomment(ui, | ||||
| node.short(state.parentctxnode), | node.short(state.parentctxnode), | ||||
| node.short(state.topmost)) | node.short(state.topmost)) | ||||
| rules = ruleeditor(repo, ui, state.actions, comment) | rules = ruleeditor(repo, ui, state.actions, comment) | ||||
| else: | else: | ||||
| rules = _readfile(ui, rules) | rules = _readfile(ui, rules) | ||||
| actions = parserules(rules, state) | actions = parserules(rules, state) | ||||
| ctxs = [repo[act.node] \ | ctxs = [repo[act.node] | ||||
| for act in state.actions if act.node] | for act in state.actions if act.node] | ||||
| warnverifyactions(ui, repo, actions, state, ctxs) | warnverifyactions(ui, repo, actions, state, ctxs) | ||||
| state.actions = actions | state.actions = actions | ||||
| state.write() | state.write() | ||||
| def _newhistedit(ui, repo, state, revs, freeargs, opts): | def _newhistedit(ui, repo, state, revs, freeargs, opts): | ||||
| outg = opts.get('outgoing') | outg = opts.get('outgoing') | ||||
| rules = opts.get('commands', '') | rules = opts.get('commands', '') | ||||
| clientextsetup(ui) | clientextsetup(ui) | ||||
| def commonsetup(ui): | def commonsetup(ui): | ||||
| wireprotov1server.commands['listkeyspatterns'] = ( | wireprotov1server.commands['listkeyspatterns'] = ( | ||||
| wireprotolistkeyspatterns, 'namespace patterns') | wireprotolistkeyspatterns, 'namespace patterns') | ||||
| scratchbranchpat = ui.config('infinitepush', 'branchpattern') | scratchbranchpat = ui.config('infinitepush', 'branchpattern') | ||||
| if scratchbranchpat: | if scratchbranchpat: | ||||
| global _scratchbranchmatcher | global _scratchbranchmatcher | ||||
| kind, pat, _scratchbranchmatcher = \ | kind, pat, _scratchbranchmatcher = ( | ||||
| stringutil.stringmatcher(scratchbranchpat) | stringutil.stringmatcher(scratchbranchpat)) | ||||
| def serverextsetup(ui): | def serverextsetup(ui): | ||||
| origpushkeyhandler = bundle2.parthandlermapping['pushkey'] | origpushkeyhandler = bundle2.parthandlermapping['pushkey'] | ||||
| def newpushkeyhandler(*args, **kwargs): | def newpushkeyhandler(*args, **kwargs): | ||||
| bundle2pushkey(origpushkeyhandler, *args, **kwargs) | bundle2pushkey(origpushkeyhandler, *args, **kwargs) | ||||
| newpushkeyhandler.params = origpushkeyhandler.params | newpushkeyhandler.params = origpushkeyhandler.params | ||||
| bundle2.parthandlermapping['pushkey'] = newpushkeyhandler | bundle2.parthandlermapping['pushkey'] = newpushkeyhandler | ||||
| orighandlephasehandler = bundle2.parthandlermapping['phase-heads'] | orighandlephasehandler = bundle2.parthandlermapping['phase-heads'] | ||||
| newphaseheadshandler = lambda *args, **kwargs: \ | newphaseheadshandler = lambda *args, **kwargs: bundle2handlephases( | ||||
| bundle2handlephases(orighandlephasehandler, *args, **kwargs) | orighandlephasehandler, *args, **kwargs) | ||||
| newphaseheadshandler.params = orighandlephasehandler.params | newphaseheadshandler.params = orighandlephasehandler.params | ||||
| bundle2.parthandlermapping['phase-heads'] = newphaseheadshandler | bundle2.parthandlermapping['phase-heads'] = newphaseheadshandler | ||||
| extensions.wrapfunction(localrepo.localrepository, 'listkeys', | extensions.wrapfunction(localrepo.localrepository, 'listkeys', | ||||
| localrepolistkeys) | localrepolistkeys) | ||||
| wireprotov1server.commands['lookup'] = ( | wireprotov1server.commands['lookup'] = ( | ||||
| _lookupwrap(wireprotov1server.commands['lookup'][0]), 'key') | _lookupwrap(wireprotov1server.commands['lookup'][0]), 'key') | ||||
| extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks) | extensions.wrapfunction(exchange, 'getbundlechunks', getbundlechunks) | ||||
| """ | """ | ||||
| remotenamesext = extensions.find('remotenames') | remotenamesext = extensions.find('remotenames') | ||||
| # remotename format is: | # remotename format is: | ||||
| # (node, nametype ("branches" or "bookmarks"), remote, name) | # (node, nametype ("branches" or "bookmarks"), remote, name) | ||||
| nametype_idx = 1 | nametype_idx = 1 | ||||
| remote_idx = 2 | remote_idx = 2 | ||||
| name_idx = 3 | name_idx = 3 | ||||
| remotenames = [remotename for remotename in \ | remotenames = [remotename for remotename in | ||||
| remotenamesext.readremotenames(repo) \ | remotenamesext.readremotenames(repo) | ||||
| if remotename[remote_idx] == path] | if remotename[remote_idx] == path] | ||||
| remote_bm_names = [remotename[name_idx] for remotename in \ | remote_bm_names = [remotename[name_idx] for remotename in | ||||
| remotenames if remotename[nametype_idx] == "bookmarks"] | remotenames if remotename[nametype_idx] == "bookmarks"] | ||||
| for name in names: | for name in names: | ||||
| if name not in remote_bm_names: | if name not in remote_bm_names: | ||||
| raise error.Abort(_("infinitepush bookmark '{}' does not exist " | raise error.Abort(_("infinitepush bookmark '{}' does not exist " | ||||
| "in path '{}'").format(name, path)) | "in path '{}'").format(name, path)) | ||||
| bookmarks = {} | bookmarks = {} | ||||
| return os.path.join(_usercachedir(ui), hash) | return os.path.join(_usercachedir(ui), hash) | ||||
| def _usercachedir(ui, name=longname): | def _usercachedir(ui, name=longname): | ||||
| '''Return the location of the "global" largefiles cache.''' | '''Return the location of the "global" largefiles cache.''' | ||||
| path = ui.configpath(name, 'usercache') | path = ui.configpath(name, 'usercache') | ||||
| if path: | if path: | ||||
| return path | return path | ||||
| if pycompat.iswindows: | if pycompat.iswindows: | ||||
| appdata = encoding.environ.get('LOCALAPPDATA',\ | appdata = encoding.environ.get('LOCALAPPDATA', | ||||
| encoding.environ.get('APPDATA')) | encoding.environ.get('APPDATA')) | ||||
| if appdata: | if appdata: | ||||
| return os.path.join(appdata, name) | return os.path.join(appdata, name) | ||||
| elif pycompat.isdarwin: | elif pycompat.isdarwin: | ||||
| home = encoding.environ.get('HOME') | home = encoding.environ.get('HOME') | ||||
| if home: | if home: | ||||
| return os.path.join(home, 'Library', 'Caches', name) | return os.path.join(home, 'Library', 'Caches', name) | ||||
| elif pycompat.isposix: | elif pycompat.isposix: | ||||
| path = encoding.environ.get('XDG_CACHE_HOME') | path = encoding.environ.get('XDG_CACHE_HOME') | ||||
| (modified, added, removed, deleted, clean) = ( | (modified, added, removed, deleted, clean) = ( | ||||
| s.modified, s.added, s.removed, s.deleted, s.clean) | s.modified, s.added, s.removed, s.deleted, s.clean) | ||||
| if parentworking: | if parentworking: | ||||
| for lfile in unsure: | for lfile in unsure: | ||||
| standin = lfutil.standin(lfile) | standin = lfutil.standin(lfile) | ||||
| if standin not in ctx1: | if standin not in ctx1: | ||||
| # from second parent | # from second parent | ||||
| modified.append(lfile) | modified.append(lfile) | ||||
| elif lfutil.readasstandin(ctx1[standin]) \ | elif (lfutil.readasstandin(ctx1[standin]) | ||||
| != lfutil.hashfile(self.wjoin(lfile)): | != lfutil.hashfile(self.wjoin(lfile))): | ||||
| modified.append(lfile) | modified.append(lfile) | ||||
| else: | else: | ||||
| if listclean: | if listclean: | ||||
| clean.append(lfile) | clean.append(lfile) | ||||
| lfdirstate.normal(lfile) | lfdirstate.normal(lfile) | ||||
| else: | else: | ||||
| tocheck = unsure + modified + added + clean | tocheck = unsure + modified + added + clean | ||||
| modified, added, clean = [], [], [] | modified, added, clean = [], [], [] | ||||
| def uisetup(ui): | def uisetup(ui): | ||||
| try: | try: | ||||
| mq = extensions.find('mq') | mq = extensions.find('mq') | ||||
| except KeyError: | except KeyError: | ||||
| return | return | ||||
| cmdtable["qrecord"] = \ | cmdtable["qrecord"] = ( | ||||
| (qrecord, | qrecord, | ||||
| # same options as qnew, but copy them so we don't get | # same options as qnew, but copy them so we don't get | ||||
| # -i/--interactive for qrecord and add white space diff options | # -i/--interactive for qrecord and add white space diff options | ||||
| mq.cmdtable['qnew'][1][:] + cmdutil.diffwsopts, | mq.cmdtable['qnew'][1][:] + cmdutil.diffwsopts, | ||||
| _('hg qrecord [OPTION]... PATCH [FILE]...')) | _('hg qrecord [OPTION]... PATCH [FILE]...')) | ||||
| _wrapcmd('qnew', mq.cmdtable, qnew, _("interactively record a new patch")) | _wrapcmd('qnew', mq.cmdtable, qnew, _("interactively record a new patch")) | ||||
| _wrapcmd('qrefresh', mq.cmdtable, qrefresh, | _wrapcmd('qrefresh', mq.cmdtable, qrefresh, | ||||
| _("interactively select changes to refresh")) | _("interactively select changes to refresh")) | ||||
| def _wrapcmd(cmd, table, wrapfn, msg): | def _wrapcmd(cmd, table, wrapfn, msg): | ||||
| entry = extensions.wrapcommand(table, cmd, wrapfn) | entry = extensions.wrapcommand(table, cmd, wrapfn) | ||||
| entry[1].append(('i', 'interactive', None, msg)) | entry[1].append(('i', 'interactive', None, msg)) | ||||
| This is used to combine multiple sources of release notes together. | This is used to combine multiple sources of release notes together. | ||||
| """ | """ | ||||
| if not fuzz: | if not fuzz: | ||||
| ui.warn(_("module 'fuzzywuzzy' not found, merging of similar " | ui.warn(_("module 'fuzzywuzzy' not found, merging of similar " | ||||
| "releasenotes is disabled\n")) | "releasenotes is disabled\n")) | ||||
| for section in other: | for section in other: | ||||
| existingnotes = converttitled(self.titledforsection(section)) + \ | existingnotes = ( | ||||
| convertnontitled(self.nontitledforsection(section)) | converttitled(self.titledforsection(section)) + | ||||
| convertnontitled(self.nontitledforsection(section))) | |||||
| for title, paragraphs in other.titledforsection(section): | for title, paragraphs in other.titledforsection(section): | ||||
| if self.hastitledinsection(section, title): | if self.hastitledinsection(section, title): | ||||
| # TODO prompt for resolution if different and running in | # TODO prompt for resolution if different and running in | ||||
| # interactive mode. | # interactive mode. | ||||
| ui.write(_('%s already exists in %s section; ignoring\n') % | ui.write(_('%s already exists in %s section; ignoring\n') % | ||||
| (title, section)) | (title, section)) | ||||
| continue | continue | ||||
| def __init__(self): | def __init__(self): | ||||
| self.pipeo = self.pipei = self.pipee = None | self.pipeo = self.pipei = self.pipee = None | ||||
| self.subprocess = None | self.subprocess = None | ||||
| self.connected = False | self.connected = False | ||||
| def connect(self, cachecommand): | def connect(self, cachecommand): | ||||
| if self.pipeo: | if self.pipeo: | ||||
| raise error.Abort(_("cache connection already open")) | raise error.Abort(_("cache connection already open")) | ||||
| self.pipei, self.pipeo, self.pipee, self.subprocess = \ | self.pipei, self.pipeo, self.pipee, self.subprocess = ( | ||||
| procutil.popen4(cachecommand) | procutil.popen4(cachecommand)) | ||||
| self.connected = True | self.connected = True | ||||
| def close(self): | def close(self): | ||||
| def tryclose(pipe): | def tryclose(pipe): | ||||
| try: | try: | ||||
| pipe.close() | pipe.close() | ||||
| except Exception: | except Exception: | ||||
| pass | pass | ||||
| return d | return d | ||||
| @classmethod | @classmethod | ||||
| def load(cls, repo): | def load(cls, repo): | ||||
| version = cls._getversion(repo) | version = cls._getversion(repo) | ||||
| if version < cls._version: | if version < cls._version: | ||||
| d = cls._readold(repo) | d = cls._readold(repo) | ||||
| elif version == cls._version: | elif version == cls._version: | ||||
| d = scmutil.simplekeyvaluefile(repo.vfs, cls._filename)\ | d = scmutil.simplekeyvaluefile( | ||||
| .read(firstlinenonkeyval=True) | repo.vfs, cls._filename).read(firstlinenonkeyval=True) | ||||
| else: | else: | ||||
| raise error.Abort(_('this version of shelve is incompatible ' | raise error.Abort(_('this version of shelve is incompatible ' | ||||
| 'with the version used in this repo')) | 'with the version used in this repo')) | ||||
| cls._verifyandtransform(d) | cls._verifyandtransform(d) | ||||
| try: | try: | ||||
| obj = cls() | obj = cls() | ||||
| obj.name = d['name'] | obj.name = d['name'] | ||||
| "parents": ' '.join([nodemod.hex(p) | "parents": ' '.join([nodemod.hex(p) | ||||
| for p in repo.dirstate.parents()]), | for p in repo.dirstate.parents()]), | ||||
| "nodestoremove": ' '.join([nodemod.hex(n) | "nodestoremove": ' '.join([nodemod.hex(n) | ||||
| for n in nodestoremove]), | for n in nodestoremove]), | ||||
| "branchtorestore": branchtorestore, | "branchtorestore": branchtorestore, | ||||
| "keep": cls._keep if keep else cls._nokeep, | "keep": cls._keep if keep else cls._nokeep, | ||||
| "activebook": activebook or cls._noactivebook | "activebook": activebook or cls._noactivebook | ||||
| } | } | ||||
| scmutil.simplekeyvaluefile(repo.vfs, cls._filename)\ | scmutil.simplekeyvaluefile( | ||||
| .write(info, firstline=("%d" % cls._version)) | repo.vfs, cls._filename).write(info, | ||||
| firstline=("%d" % cls._version)) | |||||
| @classmethod | @classmethod | ||||
| def clear(cls, repo): | def clear(cls, repo): | ||||
| repo.vfs.unlinkpath(cls._filename, ignoremissing=True) | repo.vfs.unlinkpath(cls._filename, ignoremissing=True) | ||||
| def cleanupoldbackups(repo): | def cleanupoldbackups(repo): | ||||
| vfs = vfsmod.vfs(repo.vfs.join(backupdir)) | vfs = vfsmod.vfs(repo.vfs.join(backupdir)) | ||||
| maxbackups = repo.ui.configint('shelve', 'maxbackups') | maxbackups = repo.ui.configint('shelve', 'maxbackups') | ||||
| directive = mdirective.group(1) | directive = mdirective.group(1) | ||||
| if directive in ('container', 'include'): | if directive in ('container', 'include'): | ||||
| if msgid.rstrip('\n').count('\n') == 0: | if msgid.rstrip('\n').count('\n') == 0: | ||||
| # only rst syntax, nothing to translate | # only rst syntax, nothing to translate | ||||
| delta += 2 | delta += 2 | ||||
| continue | continue | ||||
| else: | else: | ||||
| # lines following directly, unexpected | # lines following directly, unexpected | ||||
| print('Warning: text follows line with directive' \ | print('Warning: text follows line with directive' | ||||
| ' %s' % directive) | ' %s' % directive) | ||||
| comment = 'do not translate: .. %s::' % directive | comment = 'do not translate: .. %s::' % directive | ||||
| if not newentry.comment: | if not newentry.comment: | ||||
| newentry.comment = comment | newentry.comment = comment | ||||
| elif comment not in newentry.comment: | elif comment not in newentry.comment: | ||||
| newentry.comment += '\n' + comment | newentry.comment += '\n' + comment | ||||
| addentry(po, newentry, cache) | addentry(po, newentry, cache) | ||||
| delta += 2 + msgid.count('\n') | delta += 2 + msgid.count('\n') | ||||
| po.save() | po.save() | ||||
| def validfor(self, repo): | def validfor(self, repo): | ||||
| """Is the cache content valid regarding a repo | """Is the cache content valid regarding a repo | ||||
| - False when cached tipnode is unknown or if we detect a strip. | - False when cached tipnode is unknown or if we detect a strip. | ||||
| - True when cache is up to date or a subset of current repo.""" | - True when cache is up to date or a subset of current repo.""" | ||||
| try: | try: | ||||
| return ((self.tipnode == repo.changelog.node(self.tiprev)) | return ((self.tipnode == repo.changelog.node(self.tiprev)) | ||||
| and (self.filteredhash == \ | and (self.filteredhash == | ||||
| scmutil.filteredhash(repo, self.tiprev))) | scmutil.filteredhash(repo, self.tiprev))) | ||||
| except IndexError: | except IndexError: | ||||
| return False | return False | ||||
| def _branchtip(self, heads): | def _branchtip(self, heads): | ||||
| '''Return tuple with last open head in heads and false, | '''Return tuple with last open head in heads and false, | ||||
| otherwise return last closed head and true.''' | otherwise return last closed head and true.''' | ||||
| tip = heads[-1] | tip = heads[-1] | ||||
| super(seekableunbundlepart, self).__init__(ui, header, fp) | super(seekableunbundlepart, self).__init__(ui, header, fp) | ||||
| def _payloadchunks(self, chunknum=0): | def _payloadchunks(self, chunknum=0): | ||||
| '''seek to specified chunk and start yielding data''' | '''seek to specified chunk and start yielding data''' | ||||
| if len(self._chunkindex) == 0: | if len(self._chunkindex) == 0: | ||||
| assert chunknum == 0, 'Must start with chunk 0' | assert chunknum == 0, 'Must start with chunk 0' | ||||
| self._chunkindex.append((0, self._tellfp())) | self._chunkindex.append((0, self._tellfp())) | ||||
| else: | else: | ||||
| assert chunknum < len(self._chunkindex), \ | assert chunknum < len(self._chunkindex), ( | ||||
| 'Unknown chunk %d' % chunknum | 'Unknown chunk %d' % chunknum) | ||||
| self._seekfp(self._chunkindex[chunknum][1]) | self._seekfp(self._chunkindex[chunknum][1]) | ||||
| pos = self._chunkindex[chunknum][0] | pos = self._chunkindex[chunknum][0] | ||||
| for chunk in decodepayloadchunks(self.ui, self._fp): | for chunk in decodepayloadchunks(self.ui, self._fp): | ||||
| chunknum += 1 | chunknum += 1 | ||||
| pos += len(chunk) | pos += len(chunk) | ||||
| if chunknum == len(self._chunkindex): | if chunknum == len(self._chunkindex): | ||||
| def ishunk(x): | def ishunk(x): | ||||
| hunkclasses = (crecordmod.uihunk, patch.recordhunk) | hunkclasses = (crecordmod.uihunk, patch.recordhunk) | ||||
| return isinstance(x, hunkclasses) | return isinstance(x, hunkclasses) | ||||
| def newandmodified(chunks, originalchunks): | def newandmodified(chunks, originalchunks): | ||||
| newlyaddedandmodifiedfiles = set() | newlyaddedandmodifiedfiles = set() | ||||
| for chunk in chunks: | for chunk in chunks: | ||||
| if ishunk(chunk) and chunk.header.isnewfile() and chunk not in \ | if (ishunk(chunk) and chunk.header.isnewfile() and chunk not in | ||||
| originalchunks: | originalchunks): | ||||
| newlyaddedandmodifiedfiles.add(chunk.header.filename()) | newlyaddedandmodifiedfiles.add(chunk.header.filename()) | ||||
| return newlyaddedandmodifiedfiles | return newlyaddedandmodifiedfiles | ||||
| def parsealiases(cmd): | def parsealiases(cmd): | ||||
| return cmd.split("|") | return cmd.split("|") | ||||
| def setupwrapcolorwrite(ui): | def setupwrapcolorwrite(ui): | ||||
| # wrap ui.write so diff output can be labeled/colorized | # wrap ui.write so diff output can be labeled/colorized | ||||
| modified = set(status.modified) | modified = set(status.modified) | ||||
| # 2. backup changed files, so we can restore them in the end | # 2. backup changed files, so we can restore them in the end | ||||
| if backupall: | if backupall: | ||||
| tobackup = changed | tobackup = changed | ||||
| else: | else: | ||||
| tobackup = [f for f in newfiles if f in modified or f in \ | tobackup = [f for f in newfiles if f in modified or f in | ||||
| newlyaddedandmodifiedfiles] | newlyaddedandmodifiedfiles] | ||||
| backups = {} | backups = {} | ||||
| if tobackup: | if tobackup: | ||||
| backupdir = repo.vfs.join('record-backups') | backupdir = repo.vfs.join('record-backups') | ||||
| try: | try: | ||||
| os.mkdir(backupdir) | os.mkdir(backupdir) | ||||
| except OSError as err: | except OSError as err: | ||||
| if err.errno != errno.EEXIST: | if err.errno != errno.EEXIST: | ||||
| raise | raise | ||||
| extra = {} | extra = {} | ||||
| if opts.get('close_branch'): | if opts.get('close_branch'): | ||||
| extra['close'] = '1' | extra['close'] = '1' | ||||
| if not bheads: | if not bheads: | ||||
| raise error.Abort(_('can only close branch heads')) | raise error.Abort(_('can only close branch heads')) | ||||
| elif opts.get('amend'): | elif opts.get('amend'): | ||||
| if repo['.'].p1().branch() != branch and \ | if (repo['.'].p1().branch() != branch and | ||||
| repo['.'].p2().branch() != branch: | repo['.'].p2().branch() != branch): | ||||
| raise error.Abort(_('can only close branch heads')) | raise error.Abort(_('can only close branch heads')) | ||||
| if opts.get('amend'): | if opts.get('amend'): | ||||
| if ui.configbool('ui', 'commitsubrepos'): | if ui.configbool('ui', 'commitsubrepos'): | ||||
| raise error.Abort(_('cannot amend with ui.commitsubrepos enabled')) | raise error.Abort(_('cannot amend with ui.commitsubrepos enabled')) | ||||
| old = repo['.'] | old = repo['.'] | ||||
| rewriteutil.precheck(repo, [old.rev()], 'amend') | rewriteutil.precheck(repo, [old.rev()], 'amend') | ||||
| :path: String. Repository-absolute path of the file. | :path: String. Repository-absolute path of the file. | ||||
| Returns 0 on success, 1 if any files fail a resolve attempt. | Returns 0 on success, 1 if any files fail a resolve attempt. | ||||
| """ | """ | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| confirm = ui.configbool('commands', 'resolve.confirm') | confirm = ui.configbool('commands', 'resolve.confirm') | ||||
| flaglist = 'all mark unmark list no_status re_merge'.split() | flaglist = 'all mark unmark list no_status re_merge'.split() | ||||
| all, mark, unmark, show, nostatus, remerge = \ | all, mark, unmark, show, nostatus, remerge = [ | ||||
| [opts.get(o) for o in flaglist] | opts.get(o) for o in flaglist] | ||||
| actioncount = len(list(filter(None, [show, mark, unmark, remerge]))) | actioncount = len(list(filter(None, [show, mark, unmark, remerge]))) | ||||
| if actioncount > 1: | if actioncount > 1: | ||||
| raise error.Abort(_("too many actions specified")) | raise error.Abort(_("too many actions specified")) | ||||
| elif (actioncount == 0 | elif (actioncount == 0 | ||||
| and ui.configbool('commands', 'resolve.explicit-re-merge')): | and ui.configbool('commands', 'resolve.explicit-re-merge')): | ||||
| hint = _('use --mark, --unmark, --list or --re-merge') | hint = _('use --mark, --unmark, --list or --re-merge') | ||||
| raise error.Abort(_('no action specified'), hint=hint) | raise error.Abort(_('no action specified'), hint=hint) | ||||
| elif ms[f] == mergemod.MERGE_RECORD_UNRESOLVED_PATH: | elif ms[f] == mergemod.MERGE_RECORD_UNRESOLVED_PATH: | ||||
| ui.warn(_('%s: path conflict must be resolved manually\n') | ui.warn(_('%s: path conflict must be resolved manually\n') | ||||
| % uipathfn(f)) | % uipathfn(f)) | ||||
| continue | continue | ||||
| if mark: | if mark: | ||||
| if markcheck: | if markcheck: | ||||
| fdata = repo.wvfs.tryread(f) | fdata = repo.wvfs.tryread(f) | ||||
| if filemerge.hasconflictmarkers(fdata) and \ | if (filemerge.hasconflictmarkers(fdata) and | ||||
| ms[f] != mergemod.MERGE_RECORD_RESOLVED: | ms[f] != mergemod.MERGE_RECORD_RESOLVED): | ||||
| hasconflictmarkers.append(f) | hasconflictmarkers.append(f) | ||||
| ms.mark(f, mergemod.MERGE_RECORD_RESOLVED) | ms.mark(f, mergemod.MERGE_RECORD_RESOLVED) | ||||
| elif unmark: | elif unmark: | ||||
| ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED) | ms.mark(f, mergemod.MERGE_RECORD_UNRESOLVED) | ||||
| else: | else: | ||||
| # backup pre-resolve (merge uses .orig for its own purposes) | # backup pre-resolve (merge uses .orig for its own purposes) | ||||
| a = repo.wjoin(f) | a = repo.wjoin(f) | ||||
| try: | try: | ||||
| filelog=None, changectx=None): | filelog=None, changectx=None): | ||||
| """changeid must be a revision number, if specified. | """changeid must be a revision number, if specified. | ||||
| fileid can be a file revision or node.""" | fileid can be a file revision or node.""" | ||||
| self._repo = repo | self._repo = repo | ||||
| self._path = path | self._path = path | ||||
| assert (changeid is not None | assert (changeid is not None | ||||
| or fileid is not None | or fileid is not None | ||||
| or changectx is not None), \ | or changectx is not None), ( | ||||
| ("bad args: changeid=%r, fileid=%r, changectx=%r" | "bad args: changeid=%r, fileid=%r, changectx=%r" | ||||
| % (changeid, fileid, changectx)) | % (changeid, fileid, changectx)) | ||||
| if filelog is not None: | if filelog is not None: | ||||
| self._filelog = filelog | self._filelog = filelog | ||||
| if changeid is not None: | if changeid is not None: | ||||
| self._changeid = changeid | self._changeid = changeid | ||||
| if changectx is not None: | if changectx is not None: | ||||
| self._changectx = changectx | self._changectx = changectx | ||||
| age = now - st[stat.ST_MTIME] | age = now - st[stat.ST_MTIME] | ||||
| user = util.username(st.st_uid) | user = util.username(st.st_uid) | ||||
| locker = vfs.readlock(name) | locker = vfs.readlock(name) | ||||
| if ":" in locker: | if ":" in locker: | ||||
| host, pid = locker.split(':') | host, pid = locker.split(':') | ||||
| if host == socket.gethostname(): | if host == socket.gethostname(): | ||||
| locker = 'user %s, process %s' % (user or b'None', pid) | locker = 'user %s, process %s' % (user or b'None', pid) | ||||
| else: | else: | ||||
| locker = 'user %s, process %s, host %s' \ | locker = ('user %s, process %s, host %s' | ||||
| % (user or b'None', pid, host) | % (user or b'None', pid, host)) | ||||
| ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age)) | ui.write(("%-6s %s (%ds)\n") % (name + ":", locker, age)) | ||||
| return 1 | return 1 | ||||
| except OSError as e: | except OSError as e: | ||||
| if e.errno != errno.ENOENT: | if e.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| ui.write(("%-6s free\n") % (name + ":")) | ui.write(("%-6s free\n") % (name + ":")) | ||||
| return 0 | return 0 | ||||
| return m | return m | ||||
| def isstreamclonespec(bundlespec): | def isstreamclonespec(bundlespec): | ||||
| # Stream clone v1 | # Stream clone v1 | ||||
| if (bundlespec.wirecompression == 'UN' and bundlespec.wireversion == 's1'): | if (bundlespec.wirecompression == 'UN' and bundlespec.wireversion == 's1'): | ||||
| return True | return True | ||||
| # Stream clone v2 | # Stream clone v2 | ||||
| if (bundlespec.wirecompression == 'UN' and \ | if (bundlespec.wirecompression == 'UN' and | ||||
| bundlespec.wireversion == '02' and \ | bundlespec.wireversion == '02' and | ||||
| bundlespec.contentopts.get('streamv2')): | bundlespec.contentopts.get('streamv2')): | ||||
| return True | return True | ||||
| return False | return False | ||||
| def filterclonebundleentries(repo, entries, streamclonerequested=False): | def filterclonebundleentries(repo, entries, streamclonerequested=False): | ||||
| """Remove incompatible clone bundle manifest entries. | """Remove incompatible clone bundle manifest entries. | ||||
| prefixurl.user = None | prefixurl.user = None | ||||
| prefix = bytes(prefixurl) | prefix = bytes(prefixurl) | ||||
| p = prefix.split('://', 1) | p = prefix.split('://', 1) | ||||
| if len(p) > 1: | if len(p) > 1: | ||||
| schemes, prefix = [p[0]], p[1] | schemes, prefix = [p[0]], p[1] | ||||
| else: | else: | ||||
| schemes = (auth.get('schemes') or 'https').split() | schemes = (auth.get('schemes') or 'https').split() | ||||
| if (prefix == '*' or hostpath.startswith(prefix)) and \ | if ((prefix == '*' or hostpath.startswith(prefix)) and | ||||
| (len(prefix) > bestlen or (len(prefix) == bestlen and \ | (len(prefix) > bestlen or (len(prefix) == bestlen and | ||||
| not bestuser and 'username' in auth)) \ | not bestuser and 'username' in auth)) | ||||
| and scheme in schemes: | and scheme in schemes): | ||||
| bestlen = len(prefix) | bestlen = len(prefix) | ||||
| bestauth = group, auth | bestauth = group, auth | ||||
| bestuser = auth.get('username') | bestuser = auth.get('username') | ||||
| if user and not bestuser: | if user and not bestuser: | ||||
| auth['username'] = user | auth['username'] = user | ||||
| return bestauth | return bestauth | ||||
| def active(self): | def active(self): | ||||
| """Whether mergestate is active. | """Whether mergestate is active. | ||||
| Returns True if there appears to be mergestate. This is a rough proxy | Returns True if there appears to be mergestate. This is a rough proxy | ||||
| for "is a merge in progress." | for "is a merge in progress." | ||||
| """ | """ | ||||
| # Check local variables before looking at filesystem for performance | # Check local variables before looking at filesystem for performance | ||||
| # reasons. | # reasons. | ||||
| return bool(self._local) or bool(self._state) or \ | return (bool(self._local) or bool(self._state) or | ||||
| self._repo.vfs.exists(self.statepathv1) or \ | self._repo.vfs.exists(self.statepathv1) or | ||||
| self._repo.vfs.exists(self.statepathv2) | self._repo.vfs.exists(self.statepathv2)) | ||||
| def commit(self): | def commit(self): | ||||
| """Write current state on disk (if necessary)""" | """Write current state on disk (if necessary)""" | ||||
| if self._dirty: | if self._dirty: | ||||
| records = self._makerecords() | records = self._makerecords() | ||||
| self._writerecords(records) | self._writerecords(records) | ||||
| self._dirty = False | self._dirty = False | ||||
| if blocks[i]['lines'] == ['::']: | if blocks[i]['lines'] == ['::']: | ||||
| # Expanded form: remove block | # Expanded form: remove block | ||||
| del blocks[i] | del blocks[i] | ||||
| i -= 1 | i -= 1 | ||||
| elif blocks[i]['lines'][-1].endswith(' ::'): | elif blocks[i]['lines'][-1].endswith(' ::'): | ||||
| # Partially minimized form: remove space and both | # Partially minimized form: remove space and both | ||||
| # colons. | # colons. | ||||
| blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-3] | blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-3] | ||||
| elif len(blocks[i]['lines']) == 1 and \ | elif (len(blocks[i]['lines']) == 1 and | ||||
| blocks[i]['lines'][0].lstrip(' ').startswith('.. ') and \ | blocks[i]['lines'][0].lstrip(' ').startswith('.. ') and | ||||
| blocks[i]['lines'][0].find(' ', 3) == -1: | blocks[i]['lines'][0].find(' ', 3) == -1): | ||||
| # directive on its own line, not a literal block | # directive on its own line, not a literal block | ||||
| i += 1 | i += 1 | ||||
| continue | continue | ||||
| else: | else: | ||||
| # Fully minimized form: remove just one colon. | # Fully minimized form: remove just one colon. | ||||
| blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-1] | blocks[i]['lines'][-1] = blocks[i]['lines'][-1][:-1] | ||||
| # List items are formatted with a hanging indent. We must | # List items are formatted with a hanging indent. We must | ||||
| if b['type'] != 'margin': | if b['type'] != 'margin': | ||||
| pointer = 1 | pointer = 1 | ||||
| bindent = b['indent'] | bindent = b['indent'] | ||||
| while pointer < len(secs): | while pointer < len(secs): | ||||
| section = secs[-pointer][2][0] | section = secs[-pointer][2][0] | ||||
| if section['type'] != 'margin': | if section['type'] != 'margin': | ||||
| sindent = section['indent'] | sindent = section['indent'] | ||||
| if len(section['lines']) > 1: | if len(section['lines']) > 1: | ||||
| sindent += len(section['lines'][1]) - \ | sindent += (len(section['lines'][1]) - | ||||
| len(section['lines'][1].lstrip(' ')) | len(section['lines'][1].lstrip(' '))) | ||||
| if bindent >= sindent: | if bindent >= sindent: | ||||
| break | break | ||||
| pointer += 1 | pointer += 1 | ||||
| if pointer > 1: | if pointer > 1: | ||||
| blevel = secs[-pointer][1] | blevel = secs[-pointer][1] | ||||
| if section['type'] != b['type']: | if section['type'] != b['type']: | ||||
| blevel += 1 | blevel += 1 | ||||
| secs.append(('', blevel, [])) | secs.append(('', blevel, [])) | ||||
| # level for example a file that has been deleted is a special file. | # level for example a file that has been deleted is a special file. | ||||
| # The user cannot change the content of the operation, in the case of | # The user cannot change the content of the operation, in the case of | ||||
| # the deleted file he has to take the deletion or not take it, he | # the deleted file he has to take the deletion or not take it, he | ||||
| # cannot take some of it. | # cannot take some of it. | ||||
| # Newly added files are special if they are empty, they are not special | # Newly added files are special if they are empty, they are not special | ||||
| # if they have some content as we want to be able to change it | # if they have some content as we want to be able to change it | ||||
| nocontent = len(self.header) == 2 | nocontent = len(self.header) == 2 | ||||
| emptynewfile = self.isnewfile() and nocontent | emptynewfile = self.isnewfile() and nocontent | ||||
| return emptynewfile or \ | return (emptynewfile | ||||
| any(self.special_re.match(h) for h in self.header) | or any(self.special_re.match(h) for h in self.header)) | ||||
| class recordhunk(object): | class recordhunk(object): | ||||
| """patch hunk | """patch hunk | ||||
| XXX shouldn't we merge this with the other hunk class? | XXX shouldn't we merge this with the other hunk class? | ||||
| """ | """ | ||||
| def __init__(self, header, fromline, toline, proc, before, hunk, after, | def __init__(self, header, fromline, toline, proc, before, hunk, after, | ||||
| for fctx1, fctx2, hdr, hunks in diffhunks( | for fctx1, fctx2, hdr, hunks in diffhunks( | ||||
| repo, ctx1=ctx1, ctx2=ctx2, match=match, changes=changes, opts=opts, | repo, ctx1=ctx1, ctx2=ctx2, match=match, changes=changes, opts=opts, | ||||
| losedatafn=losedatafn, pathfn=pathfn, copy=copy, | losedatafn=losedatafn, pathfn=pathfn, copy=copy, | ||||
| copysourcematch=copysourcematch): | copysourcematch=copysourcematch): | ||||
| if hunksfilterfn is not None: | if hunksfilterfn is not None: | ||||
| # If the file has been removed, fctx2 is None; but this should | # If the file has been removed, fctx2 is None; but this should | ||||
| # not occur here since we catch removed files early in | # not occur here since we catch removed files early in | ||||
| # logcmdutil.getlinerangerevs() for 'hg log -L'. | # logcmdutil.getlinerangerevs() for 'hg log -L'. | ||||
| assert fctx2 is not None, \ | assert fctx2 is not None, ( | ||||
| 'fctx2 unexpectly None in diff hunks filtering' | 'fctx2 unexpectly None in diff hunks filtering') | ||||
| hunks = hunksfilterfn(fctx2, hunks) | hunks = hunksfilterfn(fctx2, hunks) | ||||
| text = ''.join(sum((list(hlines) for hrange, hlines in hunks), [])) | text = ''.join(sum((list(hlines) for hrange, hlines in hunks), [])) | ||||
| if hdr and (text or len(hdr) > 1): | if hdr and (text or len(hdr) > 1): | ||||
| yield '\n'.join(hdr) + '\n' | yield '\n'.join(hdr) + '\n' | ||||
| if text: | if text: | ||||
| yield text | yield text | ||||
| def diffhunks(repo, ctx1, ctx2, match=None, changes=None, opts=None, | def diffhunks(repo, ctx1, ctx2, match=None, changes=None, opts=None, | ||||
| yield region | yield region | ||||
| continue | continue | ||||
| issue, z1, z2, a1, a2, b1, b2 = region | issue, z1, z2, a1, a2, b1, b2 = region | ||||
| alen = a2 - a1 | alen = a2 - a1 | ||||
| blen = b2 - b1 | blen = b2 - b1 | ||||
| # find matches at the front | # find matches at the front | ||||
| ii = 0 | ii = 0 | ||||
| while ii < alen and ii < blen and \ | while (ii < alen and ii < blen and | ||||
| self.a[a1 + ii] == self.b[b1 + ii]: | self.a[a1 + ii] == self.b[b1 + ii]): | ||||
| ii += 1 | ii += 1 | ||||
| startmatches = ii | startmatches = ii | ||||
| # find matches at the end | # find matches at the end | ||||
| ii = 0 | ii = 0 | ||||
| while ii < alen and ii < blen and \ | while (ii < alen and ii < blen and | ||||
| self.a[a2 - ii - 1] == self.b[b2 - ii - 1]: | self.a[a2 - ii - 1] == self.b[b2 - ii - 1]): | ||||
| ii += 1 | ii += 1 | ||||
| endmatches = ii | endmatches = ii | ||||
| if startmatches > 0: | if startmatches > 0: | ||||
| yield 'same', a1, a1 + startmatches | yield 'same', a1, a1 + startmatches | ||||
| yield ('conflict', z1, z2, | yield ('conflict', z1, z2, | ||||
| a1 + startmatches, a2 - endmatches, | a1 + startmatches, a2 - endmatches, | ||||
| assert abase <= intbase | assert abase <= intbase | ||||
| assert bbase <= intbase | assert bbase <= intbase | ||||
| asub = amatch + (intbase - abase) | asub = amatch + (intbase - abase) | ||||
| bsub = bmatch + (intbase - bbase) | bsub = bmatch + (intbase - bbase) | ||||
| aend = asub + intlen | aend = asub + intlen | ||||
| bend = bsub + intlen | bend = bsub + intlen | ||||
| assert self.base[intbase:intend] == self.a[asub:aend], \ | assert self.base[intbase:intend] == self.a[asub:aend], ( | ||||
| (self.base[intbase:intend], self.a[asub:aend]) | (self.base[intbase:intend], self.a[asub:aend])) | ||||
| assert self.base[intbase:intend] == self.b[bsub:bend] | assert self.base[intbase:intend] == self.b[bsub:bend] | ||||
| sl.append((intbase, intend, | sl.append((intbase, intend, | ||||
| asub, aend, | asub, aend, | ||||
| bsub, bend)) | bsub, bend)) | ||||
| # advance whichever one ends first in the base text | # advance whichever one ends first in the base text | ||||
| if not usereporootpaths: | if not usereporootpaths: | ||||
| # let's treat paths as relative to cwd | # let's treat paths as relative to cwd | ||||
| root, cwd = repo.root, repo.getcwd() | root, cwd = repo.root, repo.getcwd() | ||||
| abspats = [] | abspats = [] | ||||
| for kindpat in pats: | for kindpat in pats: | ||||
| kind, pat = matchmod._patsplit(kindpat, None) | kind, pat = matchmod._patsplit(kindpat, None) | ||||
| if kind in matchmod.cwdrelativepatternkinds or kind is None: | if kind in matchmod.cwdrelativepatternkinds or kind is None: | ||||
| ap = (kind + ':' if kind else '') +\ | ap = ((kind + ':' if kind else '') + | ||||
| pathutil.canonpath(root, cwd, pat) | pathutil.canonpath(root, cwd, pat)) | ||||
| abspats.append(ap) | abspats.append(ap) | ||||
| else: | else: | ||||
| abspats.append(kindpat) | abspats.append(kindpat) | ||||
| pats = abspats | pats = abspats | ||||
| if include: | if include: | ||||
| newinclude.update(pats) | newinclude.update(pats) | ||||
| elif exclude: | elif exclude: | ||||
| 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 1 | return 1 | ||||
| def revert(self, substate, *pats, **opts): | def revert(self, substate, *pats, **opts): | ||||
| self.ui.warn(_('%s: reverting %s subrepos is unsupported\n') \ | self.ui.warn(_('%s: reverting %s subrepos is unsupported\n') | ||||
| % (substate[0], substate[2])) | % (substate[0], substate[2])) | ||||
| return [] | return [] | ||||
| def shortid(self, revid): | def shortid(self, revid): | ||||
| return revid | return revid | ||||
| def unshare(self): | def unshare(self): | ||||
| ''' | ''' | ||||
| convert this repository from shared to normal storage. | convert this repository from shared to normal storage. | ||||
| source, revision, kind = state | source, revision, kind = state | ||||
| repo = self._repo | repo = self._repo | ||||
| repo.ui.debug("getting subrepo %s\n" % self._path) | repo.ui.debug("getting subrepo %s\n" % self._path) | ||||
| if inrepo: | if inrepo: | ||||
| urepo = repo.unfiltered() | urepo = repo.unfiltered() | ||||
| ctx = urepo[revision] | ctx = urepo[revision] | ||||
| if ctx.hidden(): | if ctx.hidden(): | ||||
| urepo.ui.warn( | urepo.ui.warn( | ||||
| _('revision %s in subrepository "%s" is hidden\n') \ | _('revision %s in subrepository "%s" is hidden\n') | ||||
| % (revision[0:12], self._path)) | % (revision[0:12], self._path)) | ||||
| repo = urepo | repo = urepo | ||||
| hg.updaterepo(repo, revision, overwrite) | hg.updaterepo(repo, revision, overwrite) | ||||
| @annotatesubrepoerror | @annotatesubrepoerror | ||||
| def merge(self, state): | def merge(self, state): | ||||
| self._get(state) | self._get(state) | ||||
| cur = self._repo['.'] | cur = self._repo['.'] | ||||
| else: | else: | ||||
| cmd.extend(['--src-prefix=a/%s/' % prefix, | cmd.extend(['--src-prefix=a/%s/' % prefix, | ||||
| '--dst-prefix=b/%s/' % prefix]) | '--dst-prefix=b/%s/' % prefix]) | ||||
| if diffopts.ignorews: | if diffopts.ignorews: | ||||
| cmd.append('--ignore-all-space') | cmd.append('--ignore-all-space') | ||||
| if diffopts.ignorewsamount: | if diffopts.ignorewsamount: | ||||
| cmd.append('--ignore-space-change') | cmd.append('--ignore-space-change') | ||||
| if self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) \ | if (self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4) | ||||
| and diffopts.ignoreblanklines: | and diffopts.ignoreblanklines): | ||||
| cmd.append('--ignore-blank-lines') | cmd.append('--ignore-blank-lines') | ||||
| cmd.append(node1) | cmd.append(node1) | ||||
| if node2: | if node2: | ||||
| cmd.append(node2) | cmd.append(node2) | ||||
| output = "" | output = "" | ||||
| if match.always(): | if match.always(): | ||||
| # XXX is this really 100% correct? are there oddball special | # XXX is this really 100% correct? are there oddball special | ||||
| # cases where a global tag should outrank a local tag but won't, | # cases where a global tag should outrank a local tag but won't, | ||||
| # because cachetags does not contain rank info? | # because cachetags does not contain rank info? | ||||
| alltags = {} | alltags = {} | ||||
| _updatetags(cachetags, alltags) | _updatetags(cachetags, alltags) | ||||
| return alltags | return alltags | ||||
| for head in reversed(heads): # oldest to newest | for head in reversed(heads): # oldest to newest | ||||
| assert head in repo.changelog.nodemap, \ | assert head in repo.changelog.nodemap, ( | ||||
| "tag cache returned bogus head %s" % short(head) | "tag cache returned bogus head %s" % short(head)) | ||||
| fnodes = _filterfnodes(tagfnode, reversed(heads)) | fnodes = _filterfnodes(tagfnode, reversed(heads)) | ||||
| alltags = _tagsfromfnodes(ui, repo, fnodes) | alltags = _tagsfromfnodes(ui, repo, fnodes) | ||||
| # and update the cache (if necessary) | # and update the cache (if necessary) | ||||
| if shouldwrite: | if shouldwrite: | ||||
| _writetagcache(ui, repo, valid, alltags) | _writetagcache(ui, repo, valid, alltags) | ||||
| return alltags | return alltags | ||||
| @contextlib.contextmanager | @contextlib.contextmanager | ||||
| def timeblockedsection(self, key): | def timeblockedsection(self, key): | ||||
| # this is open-coded below - search for timeblockedsection to find them | # this is open-coded below - search for timeblockedsection to find them | ||||
| starttime = util.timer() | starttime = util.timer() | ||||
| try: | try: | ||||
| yield | yield | ||||
| finally: | finally: | ||||
| self._blockedtimes[key + '_blocked'] += \ | self._blockedtimes[key + '_blocked'] += ( | ||||
| (util.timer() - starttime) * 1000 | (util.timer() - starttime) * 1000) | ||||
| @contextlib.contextmanager | @contextlib.contextmanager | ||||
| def uninterruptible(self): | def uninterruptible(self): | ||||
| """Mark an operation as unsafe. | """Mark an operation as unsafe. | ||||
| Most operations on a repository are safe to interrupt, but a | Most operations on a repository are safe to interrupt, but a | ||||
| few are risky (for example repair.strip). This context manager | few are risky (for example repair.strip). This context manager | ||||
| lets you advise Mercurial that something risky is happening so | lets you advise Mercurial that something risky is happening so | ||||
| else: | else: | ||||
| if self._colormode is not None: | if self._colormode is not None: | ||||
| label = opts.get(r'label', '') | label = opts.get(r'label', '') | ||||
| msg = self.label(msg, label) | msg = self.label(msg, label) | ||||
| dest.write(msg) | dest.write(msg) | ||||
| except IOError as err: | except IOError as err: | ||||
| raise error.StdioError(err) | raise error.StdioError(err) | ||||
| finally: | finally: | ||||
| self._blockedtimes['stdio_blocked'] += \ | self._blockedtimes['stdio_blocked'] += ( | ||||
| (util.timer() - starttime) * 1000 | (util.timer() - starttime) * 1000) | ||||
| def write_err(self, *args, **opts): | def write_err(self, *args, **opts): | ||||
| self._write(self._ferr, *args, **opts) | self._write(self._ferr, *args, **opts) | ||||
| def _write(self, dest, *args, **opts): | def _write(self, dest, *args, **opts): | ||||
| # update write() as well if you touch this code | # update write() as well if you touch this code | ||||
| if self._isbuffered(dest): | if self._isbuffered(dest): | ||||
| label = opts.get(r'label', '') | label = opts.get(r'label', '') | ||||
| dest.flush() | dest.flush() | ||||
| except IOError as err: | except IOError as err: | ||||
| if (dest is self._ferr | if (dest is self._ferr | ||||
| and err.errno in (errno.EPIPE, errno.EIO, errno.EBADF)): | and err.errno in (errno.EPIPE, errno.EIO, errno.EBADF)): | ||||
| # no way to report the error, so ignore it | # no way to report the error, so ignore it | ||||
| return | return | ||||
| raise error.StdioError(err) | raise error.StdioError(err) | ||||
| finally: | finally: | ||||
| self._blockedtimes['stdio_blocked'] += \ | self._blockedtimes['stdio_blocked'] += ( | ||||
| (util.timer() - starttime) * 1000 | (util.timer() - starttime) * 1000) | ||||
| def _writemsg(self, dest, *args, **opts): | def _writemsg(self, dest, *args, **opts): | ||||
| _writemsgwith(self._write, dest, *args, **opts) | _writemsgwith(self._write, dest, *args, **opts) | ||||
| def _writemsgnobuf(self, dest, *args, **opts): | def _writemsgnobuf(self, dest, *args, **opts): | ||||
| _writemsgwith(self._writenobuf, dest, *args, **opts) | _writemsgwith(self._writenobuf, dest, *args, **opts) | ||||
| def flush(self): | def flush(self): | ||||
| # opencode timeblockedsection because this is a critical path | # opencode timeblockedsection because this is a critical path | ||||
| starttime = util.timer() | starttime = util.timer() | ||||
| try: | try: | ||||
| try: | try: | ||||
| self._fout.flush() | self._fout.flush() | ||||
| except IOError as err: | except IOError as err: | ||||
| if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||||
| raise error.StdioError(err) | raise error.StdioError(err) | ||||
| finally: | finally: | ||||
| try: | try: | ||||
| self._ferr.flush() | self._ferr.flush() | ||||
| except IOError as err: | except IOError as err: | ||||
| if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | if err.errno not in (errno.EPIPE, errno.EIO, errno.EBADF): | ||||
| raise error.StdioError(err) | raise error.StdioError(err) | ||||
| finally: | finally: | ||||
| self._blockedtimes['stdio_blocked'] += \ | self._blockedtimes['stdio_blocked'] += ( | ||||
| (util.timer() - starttime) * 1000 | (util.timer() - starttime) * 1000) | ||||
| def _isatty(self, fh): | def _isatty(self, fh): | ||||
| if self.configbool('ui', 'nontty'): | if self.configbool('ui', 'nontty'): | ||||
| return False | return False | ||||
| return procutil.isatty(fh) | return procutil.isatty(fh) | ||||
| def protectfinout(self): | def protectfinout(self): | ||||
| """Duplicate ui streams and redirect original if they are stdio | """Duplicate ui streams and redirect original if they are stdio | ||||
| self.mkpath(join('mercurial', modir)) | self.mkpath(join('mercurial', modir)) | ||||
| self.make_file([pofile], mobuildfile, spawn, (cmd,)) | self.make_file([pofile], mobuildfile, spawn, (cmd,)) | ||||
| class hgdist(Distribution): | class hgdist(Distribution): | ||||
| pure = False | pure = False | ||||
| cffi = ispypy | cffi = ispypy | ||||
| global_options = Distribution.global_options + \ | global_options = Distribution.global_options + [ | ||||
| [('pure', None, "use pure (slow) Python " | ('pure', None, "use pure (slow) Python code instead of C extensions"), | ||||
| "code instead of C extensions"), | |||||
| ] | ] | ||||
| def has_ext_modules(self): | def has_ext_modules(self): | ||||
| # self.ext_modules is emptied in hgbuildpy.finalize_options which is | # self.ext_modules is emptied in hgbuildpy.finalize_options which is | ||||
| # too late for some cases | # too late for some cases | ||||
| return not self.pure and Distribution.has_ext_modules(self) | return not self.pure and Distribution.has_ext_modules(self) | ||||
| # This is ugly as a one-liner. So use a variable. | # This is ugly as a one-liner. So use a variable. | ||||
| buildextnegops = dict(getattr(build_ext, 'negative_options', {})) | buildextnegops = dict(getattr(build_ext, 'negative_options', {})) | ||||
| @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(): | ||||
| return matchoutput('svn --version 2>&1', br'^svn, version') and \ | return (matchoutput('svn --version 2>&1', br'^svn, version') and | ||||
| matchoutput('svnadmin --version 2>&1', br'^svnadmin, version') | matchoutput('svnadmin --version 2>&1', br'^svnadmin, version')) | ||||
| @check("svn-bindings", "subversion python bindings") | @check("svn-bindings", "subversion python bindings") | ||||
| def has_svn_bindings(): | def has_svn_bindings(): | ||||
| try: | try: | ||||
| import svn.core | import svn.core | ||||
| version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR | version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR | ||||
| if version < (1, 4): | if version < (1, 4): | ||||
| return False | return False | ||||
| self._skipped = True | self._skipped = True | ||||
| raise unittest.SkipTest(missing[-1]) | raise unittest.SkipTest(missing[-1]) | ||||
| elif ret == 'timeout': | elif ret == 'timeout': | ||||
| self.fail('timed out') | self.fail('timed out') | ||||
| elif ret is False: | elif ret is False: | ||||
| self.fail('no result code from test') | self.fail('no result code from test') | ||||
| elif out != self._refout: | elif out != self._refout: | ||||
| # Diff generation may rely on written .err file. | # Diff generation may rely on written .err file. | ||||
| if (ret != 0 or out != self._refout) and not self._skipped \ | if ((ret != 0 or out != self._refout) and not self._skipped | ||||
| and not self._debug: | and not self._debug): | ||||
| with open(self.errpath, 'wb') as f: | with open(self.errpath, 'wb') as f: | ||||
| for line in out: | for line in out: | ||||
| f.write(line) | f.write(line) | ||||
| # The result object handles diff calculation for us. | # The result object handles diff calculation for us. | ||||
| with firstlock: | with firstlock: | ||||
| if self._result.addOutputMismatch(self, ret, out, self._refout): | if self._result.addOutputMismatch(self, ret, out, self._refout): | ||||
| # change was accepted, skip failing | # change was accepted, skip failing | ||||
| shutil.rmtree(self._testtmp, True) | shutil.rmtree(self._testtmp, True) | ||||
| shutil.rmtree(self._threadtmp, True) | shutil.rmtree(self._threadtmp, True) | ||||
| if self._usechg: | if self._usechg: | ||||
| # chgservers will stop automatically after they find the socket | # chgservers will stop automatically after they find the socket | ||||
| # files are deleted | # files are deleted | ||||
| shutil.rmtree(self._chgsockdir, True) | shutil.rmtree(self._chgsockdir, True) | ||||
| if (self._ret != 0 or self._out != self._refout) and not self._skipped \ | if ((self._ret != 0 or self._out != self._refout) and not self._skipped | ||||
| and not self._debug and self._out: | and not self._debug and self._out): | ||||
| with open(self.errpath, 'wb') as f: | with open(self.errpath, 'wb') as f: | ||||
| for line in self._out: | for line in self._out: | ||||
| f.write(line) | f.write(line) | ||||
| vlog("# Ret was:", self._ret, '(%s)' % self.name) | vlog("# Ret was:", self._ret, '(%s)' % self.name) | ||||
| def _run(self, env): | def _run(self, env): | ||||
| # This should be implemented in child classes to run tests. | # This should be implemented in child classes to run tests. | ||||
| env["HGENCODING"] = "ascii" | env["HGENCODING"] = "ascii" | ||||
| env["HGENCODINGMODE"] = "strict" | env["HGENCODINGMODE"] = "strict" | ||||
| env["HGHOSTNAME"] = "test-hostname" | env["HGHOSTNAME"] = "test-hostname" | ||||
| env['HGIPV6'] = str(int(self._useipv6)) | env['HGIPV6'] = str(int(self._useipv6)) | ||||
| # See contrib/catapipe.py for how to use this functionality. | # See contrib/catapipe.py for how to use this functionality. | ||||
| if 'HGTESTCATAPULTSERVERPIPE' not in env: | if 'HGTESTCATAPULTSERVERPIPE' not in env: | ||||
| # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the | # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the | ||||
| # non-test one in as a default, otherwise set to devnull | # non-test one in as a default, otherwise set to devnull | ||||
| env['HGTESTCATAPULTSERVERPIPE'] = \ | env['HGTESTCATAPULTSERVERPIPE'] = env.get( | ||||
| env.get('HGCATAPULTSERVERPIPE', os.devnull) | 'HGCATAPULTSERVERPIPE', os.devnull) | ||||
| extraextensions = [] | extraextensions = [] | ||||
| for opt in self._extraconfigopts: | for opt in self._extraconfigopts: | ||||
| section, key = opt.encode('utf-8').split(b'.', 1) | section, key = opt.encode('utf-8').split(b'.', 1) | ||||
| if section != 'extensions': | if section != 'extensions': | ||||
| continue | continue | ||||
| name = key.split(b'=', 1)[0] | name = key.split(b'=', 1)[0] | ||||
| extraextensions.append(name) | extraextensions.append(name) | ||||
| for option in commands.globalopts: | for option in commands.globalopts: | ||||
| option[0] and globalshort.add(option[0]) | option[0] and globalshort.add(option[0]) | ||||
| option[1] and globallong.add(option[1]) | option[1] and globallong.add(option[1]) | ||||
| for cmd, entry in commands.table.items(): | for cmd, entry in commands.table.items(): | ||||
| seenshort = globalshort.copy() | seenshort = globalshort.copy() | ||||
| seenlong = globallong.copy() | seenlong = globallong.copy() | ||||
| for option in entry[1]: | for option in entry[1]: | ||||
| if (option[0] and option[0] in seenshort) or \ | if ((option[0] and option[0] in seenshort) or | ||||
| (option[1] and option[1] in seenlong): | (option[1] and option[1] in seenlong)): | ||||
| print("command '" + cmd + "' has duplicate option " + str(option)) | print("command '" + cmd + "' has duplicate option " + str(option)) | ||||
| seenshort.add(option[0]) | seenshort.add(option[0]) | ||||
| seenlong.add(option[1]) | seenlong.add(option[1]) | ||||
| ... except AssertionError as ex: print(ex) | ... except AssertionError as ex: print(ex) | ||||
| missing newline | missing newline | ||||
| >>> try: lm(b'single backslash\n', b'single \backslash\n') | >>> try: lm(b'single backslash\n', b'single \backslash\n') | ||||
| ... except AssertionError as ex: prn(ex) | ... except AssertionError as ex: prn(ex) | ||||
| single backslash or unknown char | single backslash or unknown char | ||||
| """ | """ | ||||
| assert (expected.endswith(b'\n') | assert (expected.endswith(b'\n') | ||||
| and output.endswith(b'\n')), 'missing newline' | and output.endswith(b'\n')), 'missing newline' | ||||
| assert not re.search(br'[^ \w\\/\r\n()*?]', expected + output), \ | assert not re.search(br'[^ \w\\/\r\n()*?]', expected + output), ( | ||||
| b'single backslash or unknown char' | b'single backslash or unknown char') | ||||
| test = run_tests.TTest(b'test-run-test.t', b'.', b'.') | test = run_tests.TTest(b'test-run-test.t', b'.', b'.') | ||||
| match, exact = test.linematch(expected, output) | match, exact = test.linematch(expected, output) | ||||
| if isinstance(match, str): | if isinstance(match, str): | ||||
| return 'special: ' + match | return 'special: ' + match | ||||
| elif isinstance(match, bytes): | elif isinstance(match, bytes): | ||||
| return 'special: ' + match.decode('utf-8') | return 'special: ' + match.decode('utf-8') | ||||
| else: | else: | ||||
| return bool(match) # do not return match object | return bool(match) # do not return match object | ||||
| with self.assertRaisesRegex(error.CorruptedState, | with self.assertRaisesRegex(error.CorruptedState, | ||||
| 'dictionary.*element.*'): | 'dictionary.*element.*'): | ||||
| scmutil.simplekeyvaluefile(self.vfs, b'badfile').read() | scmutil.simplekeyvaluefile(self.vfs, b'badfile').read() | ||||
| def testfirstline(self): | def testfirstline(self): | ||||
| dw = {b'key1': b'value1'} | dw = {b'key1': b'value1'} | ||||
| scmutil.simplekeyvaluefile(self.vfs, b'fl').write(dw, firstline=b'1.0') | scmutil.simplekeyvaluefile(self.vfs, b'fl').write(dw, firstline=b'1.0') | ||||
| self.assertEqual(self.vfs.read(b'fl'), b'1.0\nkey1=value1\n') | self.assertEqual(self.vfs.read(b'fl'), b'1.0\nkey1=value1\n') | ||||
| dr = scmutil.simplekeyvaluefile(self.vfs, b'fl')\ | dr = scmutil.simplekeyvaluefile( | ||||
| .read(firstlinenonkeyval=True) | self.vfs, b'fl').read(firstlinenonkeyval=True) | ||||
| self.assertEqual(dr, {b'__firstline': b'1.0', b'key1': b'value1'}) | self.assertEqual(dr, {b'__firstline': b'1.0', b'key1': b'value1'}) | ||||
| if __name__ == "__main__": | if __name__ == "__main__": | ||||
| silenttestrunner.main(__name__) | silenttestrunner.main(__name__) | ||||