| hg-reviewers |
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgext/fsmonitor/__init__.py (2 lines) | |||
| M | hgext/gpg.py (2 lines) | |||
| M | hgext/largefiles/lfutil.py (4 lines) | |||
| M | hgext/largefiles/overrides.py (11 lines) | |||
| M | hgext/largefiles/reposetup.py (2 lines) | |||
| M | hgext/remotefilelog/remotefilelogserver.py (4 lines) | |||
| M | hgext/remotefilelog/shallowbundle.py (2 lines) | |||
| M | hgext/remotefilelog/shallowrepo.py (2 lines) | |||
| M | hgext/sparse.py (2 lines) | |||
| M | hgext/transplant.py (4 lines) | |||
| M | mercurial/changegroup.py (4 lines) | |||
| M | mercurial/dirstate.py (2 lines) | |||
| M | mercurial/fileset.py (3 lines) | |||
| M | mercurial/hgweb/webutil.py (4 lines) | |||
| M | mercurial/localrepo.py (8 lines) | |||
| M | mercurial/match.py (10 lines) | |||
| M | mercurial/narrowspec.py (2 lines) | |||
| M | mercurial/revset.py (2 lines) | |||
| M | mercurial/scmutil.py (4 lines) | |||
| M | mercurial/sparse.py (4 lines) | |||
| M | mercurial/subrepo.py (7 lines) | |||
| M | mercurial/tags.py (4 lines) | |||
| M | tests/test-manifest.py (12 lines) | |||
| M | tests/test-match.py (14 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz |
| ctx1 = self[node1] | ctx1 = self[node1] | ||||
| if isinstance(node2, context.changectx): | if isinstance(node2, context.changectx): | ||||
| ctx2 = node2 | ctx2 = node2 | ||||
| else: | else: | ||||
| ctx2 = self[node2] | ctx2 = self[node2] | ||||
| working = ctx2.rev() is None | working = ctx2.rev() is None | ||||
| parentworking = working and ctx1 == self['.'] | parentworking = working and ctx1 == self['.'] | ||||
| match = match or matchmod.always(self.root, self.getcwd()) | match = match or matchmod.always() | ||||
| # Maybe we can use this opportunity to update Watchman's state. | # Maybe we can use this opportunity to update Watchman's state. | ||||
| # Mercurial uses workingcommitctx and/or memctx to represent the part of | # Mercurial uses workingcommitctx and/or memctx to represent the part of | ||||
| # the workingctx that is to be committed. So don't update the state in | # the workingctx that is to be committed. So don't update the state in | ||||
| # that case. | # that case. | ||||
| # HG_PENDING is set in the environment when the dirstate is being updated | # HG_PENDING is set in the environment when the dirstate is being updated | ||||
| # in the middle of a transaction; we must not update our state in that | # in the middle of a transaction; we must not update our state in that | ||||
| # case, or we risk forgetting about changes in the working copy. | # case, or we risk forgetting about changes in the working copy. | ||||
| sigmessage += "%s %s %s\n" % (hexnode, sigver, sig) | sigmessage += "%s %s %s\n" % (hexnode, sigver, sig) | ||||
| # write it | # write it | ||||
| if opts['local']: | if opts['local']: | ||||
| repo.vfs.append("localsigs", sigmessage) | repo.vfs.append("localsigs", sigmessage) | ||||
| return | return | ||||
| if not opts["force"]: | if not opts["force"]: | ||||
| msigs = match.exact(repo.root, '', ['.hgsigs']) | msigs = match.exact(['.hgsigs']) | ||||
| if any(repo.status(match=msigs, unknown=True, ignored=True)): | if any(repo.status(match=msigs, unknown=True, ignored=True)): | ||||
| raise error.Abort(_("working copy of .hgsigs is changed "), | raise error.Abort(_("working copy of .hgsigs is changed "), | ||||
| hint=_("please commit .hgsigs manually")) | hint=_("please commit .hgsigs manually")) | ||||
| sigsfile = repo.wvfs(".hgsigs", "ab") | sigsfile = repo.wvfs(".hgsigs", "ab") | ||||
| sigsfile.write(sigmessage) | sigsfile.write(sigmessage) | ||||
| sigsfile.close() | sigsfile.close() | ||||
| for standin in standins: | for standin in standins: | ||||
| lfile = splitstandin(standin) | lfile = splitstandin(standin) | ||||
| lfdirstate.normallookup(lfile) | lfdirstate.normallookup(lfile) | ||||
| return lfdirstate | return lfdirstate | ||||
| def lfdirstatestatus(lfdirstate, repo): | def lfdirstatestatus(lfdirstate, repo): | ||||
| pctx = repo['.'] | pctx = repo['.'] | ||||
| match = matchmod.always(repo.root, repo.getcwd()) | match = matchmod.always() | ||||
| unsure, s = lfdirstate.status(match, subrepos=[], ignored=False, | unsure, s = lfdirstate.status(match, subrepos=[], ignored=False, | ||||
| clean=False, unknown=False) | clean=False, unknown=False) | ||||
| modified, clean = s.modified, s.clean | modified, clean = s.modified, s.clean | ||||
| for lfile in unsure: | for lfile in unsure: | ||||
| try: | try: | ||||
| fctx = pctx[standin(lfile)] | fctx = pctx[standin(lfile)] | ||||
| except LookupError: | except LookupError: | ||||
| fctx = None | fctx = None | ||||
| # are "dirty". | # are "dirty". | ||||
| if match is None or match.always(): | if match is None or match.always(): | ||||
| # Spend a bit of time here to get a list of files we know | # Spend a bit of time here to get a list of files we know | ||||
| # are modified so we can compare only against those. | # are modified so we can compare only against those. | ||||
| # It can cost a lot of time (several seconds) | # It can cost a lot of time (several seconds) | ||||
| # otherwise to update all standins if the largefiles are | # otherwise to update all standins if the largefiles are | ||||
| # large. | # large. | ||||
| lfdirstate = openlfdirstate(ui, repo) | lfdirstate = openlfdirstate(ui, repo) | ||||
| dirtymatch = matchmod.always(repo.root, repo.getcwd()) | dirtymatch = matchmod.always() | ||||
| unsure, s = lfdirstate.status(dirtymatch, subrepos=[], ignored=False, | unsure, s = lfdirstate.status(dirtymatch, subrepos=[], ignored=False, | ||||
| clean=False, unknown=False) | clean=False, unknown=False) | ||||
| modifiedfiles = unsure + s.modified + s.added + s.removed | modifiedfiles = unsure + s.modified + s.added + s.removed | ||||
| lfiles = listlfiles(repo) | lfiles = listlfiles(repo) | ||||
| # this only loops through largefiles that exist (not | # this only loops through largefiles that exist (not | ||||
| # removed/renamed) | # removed/renamed) | ||||
| for lfile in lfiles: | for lfile in lfiles: | ||||
| if lfile in modifiedfiles: | if lfile in modifiedfiles: | ||||
| @eh.wrapfunction(scmutil, 'addremove') | @eh.wrapfunction(scmutil, 'addremove') | ||||
| def scmutiladdremove(orig, repo, matcher, prefix, uipathfn, opts=None): | def scmutiladdremove(orig, repo, matcher, prefix, uipathfn, opts=None): | ||||
| if opts is None: | if opts is None: | ||||
| opts = {} | opts = {} | ||||
| if not lfutil.islfilesrepo(repo): | if not lfutil.islfilesrepo(repo): | ||||
| return orig(repo, matcher, prefix, uipathfn, opts) | return orig(repo, matcher, prefix, uipathfn, opts) | ||||
| # Get the list of missing largefiles so we can remove them | # Get the list of missing largefiles so we can remove them | ||||
| lfdirstate = lfutil.openlfdirstate(repo.ui, repo) | lfdirstate = lfutil.openlfdirstate(repo.ui, repo) | ||||
| unsure, s = lfdirstate.status(matchmod.always(repo.root, repo.getcwd()), | unsure, s = lfdirstate.status(matchmod.always(), subrepos=[], | ||||
| subrepos=[], ignored=False, clean=False, | ignored=False, clean=False, unknown=False) | ||||
| unknown=False) | |||||
| # Call into the normal remove code, but the removing of the standin, we want | # Call into the normal remove code, but the removing of the standin, we want | ||||
| # to have handled by original addremove. Monkey patching here makes sure | # to have handled by original addremove. Monkey patching here makes sure | ||||
| # we don't remove the standin in the largefiles code, preventing a very | # we don't remove the standin in the largefiles code, preventing a very | ||||
| # confused state later. | # confused state later. | ||||
| if s.deleted: | if s.deleted: | ||||
| m = copy.copy(matcher) | m = copy.copy(matcher) | ||||
| # o | x | o | (*) | # o | x | o | (*) | ||||
| # x | o | o | overwrite (as revert) | # x | o | o | overwrite (as revert) | ||||
| # o | o | o | (*) | # o | o | o | (*) | ||||
| # | # | ||||
| # (*) don't care | # (*) don't care | ||||
| # (*1) deprecated, but used internally (e.g: "rebase --collapse") | # (*1) deprecated, but used internally (e.g: "rebase --collapse") | ||||
| lfdirstate = lfutil.openlfdirstate(repo.ui, repo) | lfdirstate = lfutil.openlfdirstate(repo.ui, repo) | ||||
| unsure, s = lfdirstate.status(matchmod.always(repo.root, | unsure, s = lfdirstate.status(matchmod.always(), subrepos=[], | ||||
| repo.getcwd()), | ignored=False, clean=True, unknown=False) | ||||
| subrepos=[], ignored=False, | |||||
| clean=True, unknown=False) | |||||
| oldclean = set(s.clean) | oldclean = set(s.clean) | ||||
| pctx = repo['.'] | pctx = repo['.'] | ||||
| dctx = repo[node] | dctx = repo[node] | ||||
| for lfile in unsure + s.modified: | for lfile in unsure + s.modified: | ||||
| lfileabs = repo.wvfs.join(lfile) | lfileabs = repo.wvfs.join(lfile) | ||||
| if not repo.wvfs.exists(lfileabs): | if not repo.wvfs.exists(lfileabs): | ||||
| continue | continue | ||||
| lfhash = lfutil.hashfile(lfileabs) | lfhash = lfutil.hashfile(lfileabs) | ||||
| # some calls in this function rely on the old version of status | # some calls in this function rely on the old version of status | ||||
| self.lfstatus = False | self.lfstatus = False | ||||
| ctx1 = self[node1] | ctx1 = self[node1] | ||||
| ctx2 = self[node2] | ctx2 = self[node2] | ||||
| working = ctx2.rev() is None | working = ctx2.rev() is None | ||||
| parentworking = working and ctx1 == self['.'] | parentworking = working and ctx1 == self['.'] | ||||
| if match is None: | if match is None: | ||||
| match = matchmod.always(self.root, self.getcwd()) | match = matchmod.always() | ||||
| wlock = None | wlock = None | ||||
| try: | try: | ||||
| try: | try: | ||||
| # updating the dirstate is optional | # updating the dirstate is optional | ||||
| # so we don't wait on the lock | # so we don't wait on the lock | ||||
| wlock = self.wlock(False) | wlock = self.wlock(False) | ||||
| except error.LockError: | except error.LockError: | ||||
| includepattern = None | includepattern = None | ||||
| excludepattern = None | excludepattern = None | ||||
| for cap in (self._bundlecaps or []): | for cap in (self._bundlecaps or []): | ||||
| if cap.startswith("includepattern="): | if cap.startswith("includepattern="): | ||||
| includepattern = cap[len("includepattern="):].split('\0') | includepattern = cap[len("includepattern="):].split('\0') | ||||
| elif cap.startswith("excludepattern="): | elif cap.startswith("excludepattern="): | ||||
| excludepattern = cap[len("excludepattern="):].split('\0') | excludepattern = cap[len("excludepattern="):].split('\0') | ||||
| m = match.always(repo.root, '') | m = match.always() | ||||
| if includepattern or excludepattern: | if includepattern or excludepattern: | ||||
| m = match.match(repo.root, '', None, | m = match.match(repo.root, '', None, | ||||
| includepattern, excludepattern) | includepattern, excludepattern) | ||||
| changedfiles = list([f for f in changedfiles if not m(f)]) | changedfiles = list([f for f in changedfiles if not m(f)]) | ||||
| return orig(self, changedfiles, linknodes, commonrevs, source, | return orig(self, changedfiles, linknodes, commonrevs, source, | ||||
| *args, **kwargs) | *args, **kwargs) | ||||
| if raw: | if raw: | ||||
| excludepattern = raw.split('\0') | excludepattern = raw.split('\0') | ||||
| oldshallow = state.shallowremote | oldshallow = state.shallowremote | ||||
| oldmatch = state.match | oldmatch = state.match | ||||
| oldnoflatmf = state.noflatmf | oldnoflatmf = state.noflatmf | ||||
| try: | try: | ||||
| state.shallowremote = True | state.shallowremote = True | ||||
| state.match = match.always(repo.root, '') | state.match = match.always() | ||||
| state.noflatmf = other.get('noflatmanifest') == 'True' | state.noflatmf = other.get('noflatmanifest') == 'True' | ||||
| if includepattern or excludepattern: | if includepattern or excludepattern: | ||||
| state.match = match.match(repo.root, '', None, | state.match = match.match(repo.root, '', None, | ||||
| includepattern, excludepattern) | includepattern, excludepattern) | ||||
| streamres = wireprotov1server.stream(repo, proto) | streamres = wireprotov1server.stream(repo, proto) | ||||
| # Force the first value to execute, so the file list is computed | # Force the first value to execute, so the file list is computed | ||||
| # within the try/finally scope | # within the try/finally scope | ||||
| elif cap.startswith("excludepattern="): | elif cap.startswith("excludepattern="): | ||||
| raw = cap[len("excludepattern="):] | raw = cap[len("excludepattern="):] | ||||
| if raw: | if raw: | ||||
| excludepattern = raw.split('\0') | excludepattern = raw.split('\0') | ||||
| if includepattern or excludepattern: | if includepattern or excludepattern: | ||||
| repo.shallowmatch = match.match(repo.root, '', None, | repo.shallowmatch = match.match(repo.root, '', None, | ||||
| includepattern, excludepattern) | includepattern, excludepattern) | ||||
| else: | else: | ||||
| repo.shallowmatch = match.always(repo.root, '') | repo.shallowmatch = match.always() | ||||
| return orig(repo, outgoing, version, source, *args, **kwargs) | return orig(repo, outgoing, version, source, *args, **kwargs) | ||||
| finally: | finally: | ||||
| repo.shallowmatch = original | repo.shallowmatch = original | ||||
| def addchangegroupfiles(orig, repo, source, revmap, trp, expectedfiles, *args): | def addchangegroupfiles(orig, repo, source, revmap, trp, expectedfiles, *args): | ||||
| if not shallowutil.isenabled(repo): | if not shallowutil.isenabled(repo): | ||||
| return orig(repo, source, revmap, trp, expectedfiles, *args) | return orig(repo, source, revmap, trp, expectedfiles, *args) | ||||
| repo.fileservice.prefetch(results) | repo.fileservice.prefetch(results) | ||||
| def close(self): | def close(self): | ||||
| super(shallowrepository, self).close() | super(shallowrepository, self).close() | ||||
| self.connectionpool.close() | self.connectionpool.close() | ||||
| repo.__class__ = shallowrepository | repo.__class__ = shallowrepository | ||||
| repo.shallowmatch = match.always(repo.root, '') | repo.shallowmatch = match.always() | ||||
| makeunionstores(repo) | makeunionstores(repo) | ||||
| repo.includepattern = repo.ui.configlist("remotefilelog", "includepattern", | repo.includepattern = repo.ui.configlist("remotefilelog", "includepattern", | ||||
| None) | None) | ||||
| repo.excludepattern = repo.ui.configlist("remotefilelog", "excludepattern", | repo.excludepattern = repo.ui.configlist("remotefilelog", "excludepattern", | ||||
| None) | None) | ||||
| if not util.safehasattr(repo, 'connectionpool'): | if not util.safehasattr(repo, 'connectionpool'): | ||||
| repo.connectionpool = connectionpool.connectionpool(repo) | repo.connectionpool = connectionpool.connectionpool(repo) | ||||
| if repo.includepattern or repo.excludepattern: | if repo.includepattern or repo.excludepattern: | ||||
| repo.shallowmatch = match.match(repo.root, '', None, | repo.shallowmatch = match.match(repo.root, '', None, | ||||
| repo.includepattern, repo.excludepattern) | repo.includepattern, repo.excludepattern) | ||||
| def _setupdirstate(ui): | def _setupdirstate(ui): | ||||
| """Modify the dirstate to prevent stat'ing excluded files, | """Modify the dirstate to prevent stat'ing excluded files, | ||||
| and to prevent modifications to files outside the checkout. | and to prevent modifications to files outside the checkout. | ||||
| """ | """ | ||||
| def walk(orig, self, match, subrepos, unknown, ignored, full=True): | def walk(orig, self, match, subrepos, unknown, ignored, full=True): | ||||
| # hack to not exclude explicitly-specified paths so that they can | # hack to not exclude explicitly-specified paths so that they can | ||||
| # be warned later on e.g. dirstate.add() | # be warned later on e.g. dirstate.add() | ||||
| em = matchmod.exact(None, None, match.files()) | em = matchmod.exact(match.files()) | ||||
| sm = matchmod.unionmatcher([self._sparsematcher, em]) | sm = matchmod.unionmatcher([self._sparsematcher, em]) | ||||
| match = matchmod.intersectmatchers(match, sm) | match = matchmod.intersectmatchers(match, sm) | ||||
| return orig(self, match, subrepos, unknown, ignored, full) | return orig(self, match, subrepos, unknown, ignored, full) | ||||
| extensions.wrapfunction(dirstate.dirstate, 'walk', walk) | extensions.wrapfunction(dirstate.dirstate, 'walk', walk) | ||||
| # dirstate.rebuild should not add non-matching files | # dirstate.rebuild should not add non-matching files | ||||
| def _rebuild(orig, self, parent, allfiles, changedfiles=None): | def _rebuild(orig, self, parent, allfiles, changedfiles=None): | ||||
| self.ui.write(stringutil.forcebytestr(inst) + '\n') | self.ui.write(stringutil.forcebytestr(inst) + '\n') | ||||
| raise TransplantError(_('fix up the working directory and run ' | raise TransplantError(_('fix up the working directory and run ' | ||||
| 'hg transplant --continue')) | 'hg transplant --continue')) | ||||
| else: | else: | ||||
| files = None | files = None | ||||
| if merge: | if merge: | ||||
| p1 = repo.dirstate.p1() | p1 = repo.dirstate.p1() | ||||
| repo.setparents(p1, node) | repo.setparents(p1, node) | ||||
| m = match.always(repo.root, '') | m = match.always() | ||||
| else: | else: | ||||
| m = match.exact(repo.root, '', files) | m = match.exact(files) | ||||
| n = repo.commit(message, user, date, extra=extra, match=m, | n = repo.commit(message, user, date, extra=extra, match=m, | ||||
| editor=self.getcommiteditor()) | editor=self.getcommiteditor()) | ||||
| if not n: | if not n: | ||||
| self.ui.warn(_('skipping emptied changeset %s\n') % | self.ui.warn(_('skipping emptied changeset %s\n') % | ||||
| nodemod.short(node)) | nodemod.short(node)) | ||||
| return None | return None | ||||
| if not merge: | if not merge: | ||||
| return min(versions) | return min(versions) | ||||
| def getbundler(version, repo, bundlecaps=None, oldmatcher=None, | def getbundler(version, repo, bundlecaps=None, oldmatcher=None, | ||||
| matcher=None, ellipses=False, shallow=False, | matcher=None, ellipses=False, shallow=False, | ||||
| ellipsisroots=None, fullnodes=None): | ellipsisroots=None, fullnodes=None): | ||||
| assert version in supportedoutgoingversions(repo) | assert version in supportedoutgoingversions(repo) | ||||
| if matcher is None: | if matcher is None: | ||||
| matcher = matchmod.always(repo.root, '') | matcher = matchmod.always() | ||||
| if oldmatcher is None: | if oldmatcher is None: | ||||
| oldmatcher = matchmod.never(repo.root, '') | oldmatcher = matchmod.never() | ||||
| if version == '01' and not matcher.always(): | if version == '01' and not matcher.always(): | ||||
| raise error.ProgrammingError('version 01 changegroups do not support ' | raise error.ProgrammingError('version 01 changegroups do not support ' | ||||
| 'sparse file matchers') | 'sparse file matchers') | ||||
| if ellipses and version in (b'01', b'02'): | if ellipses and version in (b'01', b'02'): | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _('ellipsis nodes require at least cg3 on client and server, ' | _('ellipsis nodes require at least cg3 on client and server, ' | ||||
| def hasdir(self, d): | def hasdir(self, d): | ||||
| return self._map.hastrackeddir(d) | return self._map.hastrackeddir(d) | ||||
| @rootcache('.hgignore') | @rootcache('.hgignore') | ||||
| def _ignore(self): | def _ignore(self): | ||||
| files = self._ignorefiles() | files = self._ignorefiles() | ||||
| if not files: | if not files: | ||||
| return matchmod.never(self._root, '') | return matchmod.never() | ||||
| pats = ['include:%s' % f for f in files] | pats = ['include:%s' % f for f in files] | ||||
| return matchmod.match(self._root, '', [], pats, warn=self._ui.warn) | return matchmod.match(self._root, '', [], pats, warn=self._ui.warn) | ||||
| @propertycache | @propertycache | ||||
| def _slash(self): | def _slash(self): | ||||
| return self._ui.configbool('ui', 'slash') and pycompat.ossep != '/' | return self._ui.configbool('ui', 'slash') and pycompat.ossep != '/' | ||||
| fctx = ctx[f] | fctx = ctx[f] | ||||
| except error.LookupError: | except error.LookupError: | ||||
| return False | return False | ||||
| return predfn(fctx) | return predfn(fctx) | ||||
| return self.predicate(fctxpredfn, predrepr=predrepr, cache=cache) | return self.predicate(fctxpredfn, predrepr=predrepr, cache=cache) | ||||
| def never(self): | def never(self): | ||||
| """Create a matcher to select nothing""" | """Create a matcher to select nothing""" | ||||
| repo = self.ctx.repo() | return matchmod.never(badfn=self._badfn) | ||||
| return matchmod.never(repo.root, repo.getcwd(), badfn=self._badfn) | |||||
| def match(ctx, expr, badfn=None): | def match(ctx, expr, badfn=None): | ||||
| """Create a matcher for a single fileset expression""" | """Create a matcher for a single fileset expression""" | ||||
| tree = filesetlang.parse(expr) | tree = filesetlang.parse(expr) | ||||
| tree = filesetlang.analyze(tree) | tree = filesetlang.analyze(tree) | ||||
| tree = filesetlang.optimize(tree) | tree = filesetlang.optimize(tree) | ||||
| mctx = matchctx(ctx.p1(), ctx, badfn=badfn) | mctx = matchctx(ctx.p1(), ctx, badfn=badfn) | ||||
| return getmatch(mctx, tree) | return getmatch(mctx, tree) | ||||
| 'lineno': lineno, | 'lineno': lineno, | ||||
| 'lineid': lineidprefix + "l%s" % difflineno, | 'lineid': lineidprefix + "l%s" % difflineno, | ||||
| 'linenumber': "% 8s" % difflineno, | 'linenumber': "% 8s" % difflineno, | ||||
| }) | }) | ||||
| def _diffsgen(context, repo, ctx, basectx, files, style, stripecount, | def _diffsgen(context, repo, ctx, basectx, files, style, stripecount, | ||||
| linerange, lineidprefix): | linerange, lineidprefix): | ||||
| if files: | if files: | ||||
| m = match.exact(repo.root, repo.getcwd(), files) | m = match.exact(files) | ||||
| else: | else: | ||||
| m = match.always(repo.root, repo.getcwd()) | m = match.always() | ||||
| diffopts = patch.diffopts(repo.ui, untrusted=True) | diffopts = patch.diffopts(repo.ui, untrusted=True) | ||||
| parity = paritygen(stripecount) | parity = paritygen(stripecount) | ||||
| diffhunks = patch.diffhunks(repo, basectx, ctx, m, opts=diffopts) | diffhunks = patch.diffhunks(repo, basectx, ctx, m, opts=diffopts) | ||||
| for blockno, (fctx1, fctx2, header, hunks) in enumerate(diffhunks, 1): | for blockno, (fctx1, fctx2, header, hunks) in enumerate(diffhunks, 1): | ||||
| if style != 'raw': | if style != 'raw': | ||||
| header = header[1:] | header = header[1:] | ||||
| A tuple of (includes, excludes). | A tuple of (includes, excludes). | ||||
| """ | """ | ||||
| return narrowspec.load(self) | return narrowspec.load(self) | ||||
| @storecache(narrowspec.FILENAME) | @storecache(narrowspec.FILENAME) | ||||
| def _storenarrowmatch(self): | def _storenarrowmatch(self): | ||||
| if repository.NARROW_REQUIREMENT not in self.requirements: | if repository.NARROW_REQUIREMENT not in self.requirements: | ||||
| return matchmod.always(self.root, '') | return matchmod.always() | ||||
| include, exclude = self.narrowpats | include, exclude = self.narrowpats | ||||
| return narrowspec.match(self.root, include=include, exclude=exclude) | return narrowspec.match(self.root, include=include, exclude=exclude) | ||||
| @storecache(narrowspec.FILENAME) | @storecache(narrowspec.FILENAME) | ||||
| def _narrowmatch(self): | def _narrowmatch(self): | ||||
| if repository.NARROW_REQUIREMENT not in self.requirements: | if repository.NARROW_REQUIREMENT not in self.requirements: | ||||
| return matchmod.always(self.root, '') | return matchmod.always() | ||||
| narrowspec.checkworkingcopynarrowspec(self) | narrowspec.checkworkingcopynarrowspec(self) | ||||
| include, exclude = self.narrowpats | include, exclude = self.narrowpats | ||||
| return narrowspec.match(self.root, include=include, exclude=exclude) | return narrowspec.match(self.root, include=include, exclude=exclude) | ||||
| def narrowmatch(self, match=None, includeexact=False): | def narrowmatch(self, match=None, includeexact=False): | ||||
| """matcher corresponding the the repo's narrowspec | """matcher corresponding the the repo's narrowspec | ||||
| If `match` is given, then that will be intersected with the narrow | If `match` is given, then that will be intersected with the narrow | ||||
| matcher. | matcher. | ||||
| If `includeexact` is True, then any exact matches from `match` will | If `includeexact` is True, then any exact matches from `match` will | ||||
| be included even if they're outside the narrowspec. | be included even if they're outside the narrowspec. | ||||
| """ | """ | ||||
| if match: | if match: | ||||
| if includeexact and not self._narrowmatch.always(): | if includeexact and not self._narrowmatch.always(): | ||||
| # do not exclude explicitly-specified paths so that they can | # do not exclude explicitly-specified paths so that they can | ||||
| # be warned later on | # be warned later on | ||||
| em = matchmod.exact(None, None, match.files()) | em = matchmod.exact(match.files()) | ||||
| nm = matchmod.unionmatcher([self._narrowmatch, em]) | nm = matchmod.unionmatcher([self._narrowmatch, em]) | ||||
| return matchmod.intersectmatchers(match, nm) | return matchmod.intersectmatchers(match, nm) | ||||
| return matchmod.intersectmatchers(match, self._narrowmatch) | return matchmod.intersectmatchers(match, self._narrowmatch) | ||||
| return self._narrowmatch | return self._narrowmatch | ||||
| def setnarrowpats(self, newincludes, newexcludes): | def setnarrowpats(self, newincludes, newexcludes): | ||||
| narrowspec.save(self, newincludes, newexcludes) | narrowspec.save(self, newincludes, newexcludes) | ||||
| self.invalidate(clearfilecache=True) | self.invalidate(clearfilecache=True) | ||||
| """ | """ | ||||
| if extra is None: | if extra is None: | ||||
| extra = {} | extra = {} | ||||
| def fail(f, msg): | def fail(f, msg): | ||||
| raise error.Abort('%s: %s' % (f, msg)) | raise error.Abort('%s: %s' % (f, msg)) | ||||
| if not match: | if not match: | ||||
| match = matchmod.always(self.root, '') | match = matchmod.always() | ||||
| if not force: | if not force: | ||||
| vdirs = [] | vdirs = [] | ||||
| match.explicitdir = vdirs.append | match.explicitdir = vdirs.append | ||||
| match.bad = fail | match.bad = fail | ||||
| # lock() for recent changelog (see issue4368) | # lock() for recent changelog (see issue4368) | ||||
| with self.wlock(), self.lock(): | with self.wlock(), self.lock(): | ||||
| m = intersectmatchers(m, im) | m = intersectmatchers(m, im) | ||||
| if exclude: | if exclude: | ||||
| kindpats = normalize(exclude, 'glob', root, cwd, auditor, warn) | kindpats = normalize(exclude, 'glob', root, cwd, auditor, warn) | ||||
| em = _buildkindpatsmatcher(includematcher, root, kindpats, ctx=ctx, | em = _buildkindpatsmatcher(includematcher, root, kindpats, ctx=ctx, | ||||
| listsubrepos=listsubrepos, badfn=None) | listsubrepos=listsubrepos, badfn=None) | ||||
| m = differencematcher(m, em) | m = differencematcher(m, em) | ||||
| return m | return m | ||||
| def exact(root, cwd, files, badfn=None): | def exact(files, badfn=None): | ||||
| return exactmatcher(files, badfn=badfn) | return exactmatcher(files, badfn=badfn) | ||||
| def always(root, cwd, badfn=None): | def always(badfn=None): | ||||
| return alwaysmatcher(badfn=badfn) | return alwaysmatcher(badfn) | ||||
| def never(root, cwd, badfn=None): | def never(badfn=None): | ||||
| return nevermatcher(badfn=badfn) | return nevermatcher(badfn) | ||||
| def badmatch(match, badfn): | def badmatch(match, badfn): | ||||
| """Make a copy of the given matcher, replacing its bad method with the given | """Make a copy of the given matcher, replacing its bad method with the given | ||||
| one. | one. | ||||
| """ | """ | ||||
| m = copy.copy(match) | m = copy.copy(match) | ||||
| m.bad = badfn | m.bad = badfn | ||||
| return m | return m | ||||
| output += e + '\n' | output += e + '\n' | ||||
| return output | return output | ||||
| def match(root, include=None, exclude=None): | def match(root, include=None, exclude=None): | ||||
| if not include: | if not include: | ||||
| # Passing empty include and empty exclude to matchmod.match() | # Passing empty include and empty exclude to matchmod.match() | ||||
| # gives a matcher that matches everything, so explicitly use | # gives a matcher that matches everything, so explicitly use | ||||
| # the nevermatcher. | # the nevermatcher. | ||||
| return matchmod.never(root, '') | return matchmod.never() | ||||
| return matchmod.match(root, '', [], include=include or [], | return matchmod.match(root, '', [], include=include or [], | ||||
| exclude=exclude or []) | exclude=exclude or []) | ||||
| def parseconfig(ui, spec): | def parseconfig(ui, spec): | ||||
| # maybe we should care about the profiles returned too | # maybe we should care about the profiles returned too | ||||
| includepats, excludepats, profiles = sparse.parseconfig(ui, spec, 'narrow') | includepats, excludepats, profiles = sparse.parseconfig(ui, spec, 'narrow') | ||||
| if profiles: | if profiles: | ||||
| raise error.Abort(_("including other spec files using '%include' is not" | raise error.Abort(_("including other spec files using '%include' is not" | ||||
| pattern is named, any subrepo changes are returned. | pattern is named, any subrepo changes are returned. | ||||
| """ | """ | ||||
| # i18n: "subrepo" is a keyword | # i18n: "subrepo" is a keyword | ||||
| args = getargs(x, 0, 1, _('subrepo takes at most one argument')) | args = getargs(x, 0, 1, _('subrepo takes at most one argument')) | ||||
| pat = None | pat = None | ||||
| if len(args) != 0: | if len(args) != 0: | ||||
| pat = getstring(args[0], _("subrepo requires a pattern")) | pat = getstring(args[0], _("subrepo requires a pattern")) | ||||
| m = matchmod.exact(repo.root, repo.root, ['.hgsubstate']) | m = matchmod.exact(['.hgsubstate']) | ||||
| def submatches(names): | def submatches(names): | ||||
| k, p, m = stringutil.stringmatcher(pat) | k, p, m = stringutil.stringmatcher(pat) | ||||
| for name in names: | for name in names: | ||||
| if m(name): | if m(name): | ||||
| yield name | yield name | ||||
| def matches(x): | def matches(x): | ||||
| def match(ctx, pats=(), opts=None, globbed=False, default='relpath', | def match(ctx, pats=(), opts=None, globbed=False, default='relpath', | ||||
| badfn=None): | badfn=None): | ||||
| '''Return a matcher that will warn about bad matches.''' | '''Return a matcher that will warn about bad matches.''' | ||||
| return matchandpats(ctx, pats, opts, globbed, default, badfn=badfn)[0] | return matchandpats(ctx, pats, opts, globbed, default, badfn=badfn)[0] | ||||
| def matchall(repo): | def matchall(repo): | ||||
| '''Return a matcher that will efficiently match everything.''' | '''Return a matcher that will efficiently match everything.''' | ||||
| return matchmod.always(repo.root, repo.getcwd()) | return matchmod.always() | ||||
| def matchfiles(repo, files, badfn=None): | def matchfiles(repo, files, badfn=None): | ||||
| '''Return a matcher that will efficiently match exactly these files.''' | '''Return a matcher that will efficiently match exactly these files.''' | ||||
| return matchmod.exact(repo.root, repo.getcwd(), files, badfn=badfn) | return matchmod.exact(files, badfn=badfn) | ||||
| def parsefollowlinespattern(repo, rev, pat, msg): | def parsefollowlinespattern(repo, rev, pat, msg): | ||||
| """Return a file name from `pat` pattern suitable for usage in followlines | """Return a file name from `pat` pattern suitable for usage in followlines | ||||
| logic. | logic. | ||||
| """ | """ | ||||
| if not matchmod.patkind(pat): | if not matchmod.patkind(pat): | ||||
| return pathutil.canonpath(repo.root, repo.getcwd(), pat) | return pathutil.canonpath(repo.root, repo.getcwd(), pat) | ||||
| else: | else: | ||||
| If multiple revisions are specified, the matcher is the union of all | If multiple revisions are specified, the matcher is the union of all | ||||
| revs. | revs. | ||||
| ``includetemp`` indicates whether to use the temporary sparse profile. | ``includetemp`` indicates whether to use the temporary sparse profile. | ||||
| """ | """ | ||||
| # If sparse isn't enabled, sparse matcher matches everything. | # If sparse isn't enabled, sparse matcher matches everything. | ||||
| if not enabled: | if not enabled: | ||||
| return matchmod.always(repo.root, '') | return matchmod.always() | ||||
| if not revs or revs == [None]: | if not revs or revs == [None]: | ||||
| revs = [repo.changelog.rev(node) | revs = [repo.changelog.rev(node) | ||||
| for node in repo.dirstate.parents() if node != nullid] | for node in repo.dirstate.parents() if node != nullid] | ||||
| signature = configsignature(repo, includetemp=includetemp) | signature = configsignature(repo, includetemp=includetemp) | ||||
| key = '%s %s' % (signature, ' '.join(map(pycompat.bytestr, revs))) | key = '%s %s' % (signature, ' '.join(map(pycompat.bytestr, revs))) | ||||
| matcher = matchmod.match(repo.root, '', [], | matcher = matchmod.match(repo.root, '', [], | ||||
| include=includes, exclude=excludes, | include=includes, exclude=excludes, | ||||
| default='relpath') | default='relpath') | ||||
| matchers.append(matcher) | matchers.append(matcher) | ||||
| except IOError: | except IOError: | ||||
| pass | pass | ||||
| if not matchers: | if not matchers: | ||||
| result = matchmod.always(repo.root, '') | result = matchmod.always() | ||||
| elif len(matchers) == 1: | elif len(matchers) == 1: | ||||
| result = matchers[0] | result = matchers[0] | ||||
| else: | else: | ||||
| result = matchmod.unionmatcher(matchers) | result = matchmod.unionmatcher(matchers) | ||||
| if includetemp: | if includetemp: | ||||
| tempincludes = readtemporaryincludes(repo) | tempincludes = readtemporaryincludes(repo) | ||||
| result = forceincludematcher(result, tempincludes) | result = forceincludematcher(result, tempincludes) | ||||
| raise NotImplementedError | raise NotImplementedError | ||||
| def fileflags(self, name): | def fileflags(self, name): | ||||
| """return file flags""" | """return file flags""" | ||||
| return '' | return '' | ||||
| def matchfileset(self, expr, badfn=None): | def matchfileset(self, expr, badfn=None): | ||||
| """Resolve the fileset expression for this repo""" | """Resolve the fileset expression for this repo""" | ||||
| return matchmod.never(self.wvfs.base, '', badfn=badfn) | return matchmod.never(badfn=badfn) | ||||
| def printfiles(self, ui, m, fm, fmt, subrepos): | def printfiles(self, ui, m, fm, fmt, subrepos): | ||||
| """handle the files command for this subrepo""" | """handle the files command for this subrepo""" | ||||
| return 1 | return 1 | ||||
| def archive(self, archiver, prefix, match=None, decode=True): | def archive(self, archiver, prefix, match=None, decode=True): | ||||
| if match is not None: | if match is not None: | ||||
| files = [f for f in self.files() if match(f)] | files = [f for f in self.files() if match(f)] | ||||
| ctx = self._repo[None] | ctx = self._repo[None] | ||||
| else: | else: | ||||
| rev = self._state[1] | rev = self._state[1] | ||||
| ctx = self._repo[rev] | ctx = self._repo[rev] | ||||
| return cmdutil.files(ui, ctx, m, fm, fmt, subrepos) | return cmdutil.files(ui, ctx, m, fm, fmt, subrepos) | ||||
| @annotatesubrepoerror | @annotatesubrepoerror | ||||
| def matchfileset(self, expr, badfn=None): | def matchfileset(self, expr, badfn=None): | ||||
| repo = self._repo | |||||
| if self._ctx.rev() is None: | if self._ctx.rev() is None: | ||||
| ctx = repo[None] | ctx = self._repo[None] | ||||
| else: | else: | ||||
| rev = self._state[1] | rev = self._state[1] | ||||
| ctx = repo[rev] | ctx = self._repo[rev] | ||||
| matchers = [ctx.matchfileset(expr, badfn=badfn)] | matchers = [ctx.matchfileset(expr, badfn=badfn)] | ||||
| for subpath in ctx.substate: | for subpath in ctx.substate: | ||||
| sub = ctx.sub(subpath) | sub = ctx.sub(subpath) | ||||
| try: | try: | ||||
| sm = sub.matchfileset(expr, badfn=badfn) | sm = sub.matchfileset(expr, badfn=badfn) | ||||
| message: commit message to use if committing | message: commit message to use if committing | ||||
| user: name of user to use if committing | user: name of user to use if committing | ||||
| date: date tuple to use if committing''' | date: date tuple to use if committing''' | ||||
| if not local: | if not local: | ||||
| m = matchmod.exact(repo.root, '', ['.hgtags']) | m = matchmod.exact(['.hgtags']) | ||||
| if any(repo.status(match=m, unknown=True, ignored=True)): | if any(repo.status(match=m, unknown=True, ignored=True)): | ||||
| raise error.Abort(_('working copy of .hgtags is changed'), | raise error.Abort(_('working copy of .hgtags is changed'), | ||||
| hint=_('please commit .hgtags manually')) | hint=_('please commit .hgtags manually')) | ||||
| with repo.wlock(): | with repo.wlock(): | ||||
| repo.tags() # instantiate the cache | repo.tags() # instantiate the cache | ||||
| _tag(repo, names, node, message, local, user, date, | _tag(repo, names, node, message, local, user, date, | ||||
| editor=editor) | editor=editor) | ||||
| fp.close() | fp.close() | ||||
| repo.invalidatecaches() | repo.invalidatecaches() | ||||
| if '.hgtags' not in repo.dirstate: | if '.hgtags' not in repo.dirstate: | ||||
| repo[None].add(['.hgtags']) | repo[None].add(['.hgtags']) | ||||
| m = matchmod.exact(repo.root, '', ['.hgtags']) | m = matchmod.exact(['.hgtags']) | ||||
| tagnode = repo.commit(message, user, date, extra=extra, match=m, | tagnode = repo.commit(message, user, date, extra=extra, match=m, | ||||
| editor=editor) | editor=editor) | ||||
| for name in names: | for name in names: | ||||
| repo.hook('tag', node=hex(node), tag=name, local=local) | repo.hook('tag', node=hex(node), tag=name, local=local) | ||||
| return tagnode | return tagnode | ||||
| self.assertEqual(len(m), len(list(m))) | self.assertEqual(len(m), len(list(m))) | ||||
| def testMatchesMetadata(self): | def testMatchesMetadata(self): | ||||
| '''Tests matches() for a few specific files to make sure that both | '''Tests matches() for a few specific files to make sure that both | ||||
| the set of files as well as their flags and nodeids are correct in | the set of files as well as their flags and nodeids are correct in | ||||
| the resulting manifest.''' | the resulting manifest.''' | ||||
| m = self.parsemanifest(A_HUGE_MANIFEST) | m = self.parsemanifest(A_HUGE_MANIFEST) | ||||
| match = matchmod.exact(b'/', b'', | match = matchmod.exact([b'file1', b'file200', b'file300']) | ||||
| [b'file1', b'file200', b'file300']) | |||||
| m2 = m.matches(match) | m2 = m.matches(match) | ||||
| w = (b'file1\0%sx\n' | w = (b'file1\0%sx\n' | ||||
| b'file200\0%sl\n' | b'file200\0%sl\n' | ||||
| b'file300\0%s\n') % (HASH_2, HASH_1, HASH_1) | b'file300\0%s\n') % (HASH_2, HASH_1, HASH_1) | ||||
| self.assertEqual(w, m2.text()) | self.assertEqual(w, m2.text()) | ||||
| def testMatchesNonexistentFile(self): | def testMatchesNonexistentFile(self): | ||||
| '''Tests matches() for a small set of specific files, including one | '''Tests matches() for a small set of specific files, including one | ||||
| nonexistent file to make sure in only matches against existing files. | nonexistent file to make sure in only matches against existing files. | ||||
| ''' | ''' | ||||
| m = self.parsemanifest(A_DEEPER_MANIFEST) | m = self.parsemanifest(A_DEEPER_MANIFEST) | ||||
| match = matchmod.exact(b'/', b'', | match = matchmod.exact([b'a/b/c/bar.txt', b'a/b/d/qux.py', | ||||
| [b'a/b/c/bar.txt', b'a/b/d/qux.py', | |||||
| b'readme.txt', b'nonexistent']) | b'readme.txt', b'nonexistent']) | ||||
| m2 = m.matches(match) | m2 = m.matches(match) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| [b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt'], | [b'a/b/c/bar.txt', b'a/b/d/qux.py', b'readme.txt'], | ||||
| m2.keys()) | m2.keys()) | ||||
| def testMatchesNonexistentDirectory(self): | def testMatchesNonexistentDirectory(self): | ||||
| '''Tests matches() for a relpath match on a directory that doesn't | '''Tests matches() for a relpath match on a directory that doesn't | ||||
| actually exist.''' | actually exist.''' | ||||
| m = self.parsemanifest(A_DEEPER_MANIFEST) | m = self.parsemanifest(A_DEEPER_MANIFEST) | ||||
| match = matchmod.match(b'/', b'', [b'a/f'], default=b'relpath') | match = matchmod.match(b'/', b'', [b'a/f'], default=b'relpath') | ||||
| m2 = m.matches(match) | m2 = m.matches(match) | ||||
| self.assertEqual([], m2.keys()) | self.assertEqual([], m2.keys()) | ||||
| def testMatchesExactLarge(self): | def testMatchesExactLarge(self): | ||||
| '''Tests matches() for files matching a large list of exact files. | '''Tests matches() for files matching a large list of exact files. | ||||
| ''' | ''' | ||||
| m = self.parsemanifest(A_HUGE_MANIFEST) | m = self.parsemanifest(A_HUGE_MANIFEST) | ||||
| flist = m.keys()[80:300] | flist = m.keys()[80:300] | ||||
| match = matchmod.exact(b'/', b'', flist) | match = matchmod.exact(flist) | ||||
| m2 = m.matches(match) | m2 = m.matches(match) | ||||
| self.assertEqual(flist, m2.keys()) | self.assertEqual(flist, m2.keys()) | ||||
| def testMatchesFull(self): | def testMatchesFull(self): | ||||
| '''Tests matches() for what should be a full match.''' | '''Tests matches() for what should be a full match.''' | ||||
| m = self.parsemanifest(A_DEEPER_MANIFEST) | m = self.parsemanifest(A_DEEPER_MANIFEST) | ||||
| b'a/b/fish.py'], m2.keys()) | b'a/b/fish.py'], m2.keys()) | ||||
| def testMatchesExactPath(self): | def testMatchesExactPath(self): | ||||
| '''Tests matches() on an exact match on a directory, which should | '''Tests matches() on an exact match on a directory, which should | ||||
| result in an empty manifest because you can't perform an exact match | result in an empty manifest because you can't perform an exact match | ||||
| against a directory.''' | against a directory.''' | ||||
| m = self.parsemanifest(A_DEEPER_MANIFEST) | m = self.parsemanifest(A_DEEPER_MANIFEST) | ||||
| match = matchmod.exact(b'/', b'', [b'a/b']) | match = matchmod.exact([b'a/b']) | ||||
| m2 = m.matches(match) | m2 = m.matches(match) | ||||
| self.assertEqual([], m2.keys()) | self.assertEqual([], m2.keys()) | ||||
| def testMatchesCwd(self): | def testMatchesCwd(self): | ||||
| '''Tests matches() on a relpath match with the current directory ('.') | '''Tests matches() on a relpath match with the current directory ('.') | ||||
| when not in the root directory.''' | when not in the root directory.''' | ||||
| m = self.parsemanifest(A_DEEPER_MANIFEST) | m = self.parsemanifest(A_DEEPER_MANIFEST) | ||||
| self.assertEqual(m.visitchildrenset(b'dir'), b'this') | self.assertEqual(m.visitchildrenset(b'dir'), b'this') | ||||
| # OPT: these should probably be set(). | # OPT: these should probably be set(). | ||||
| self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') | self.assertEqual(m.visitchildrenset(b'dir/subdir'), b'this') | ||||
| self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') | self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), b'this') | ||||
| class ExactMatcherTests(unittest.TestCase): | class ExactMatcherTests(unittest.TestCase): | ||||
| def testVisitdir(self): | def testVisitdir(self): | ||||
| m = matchmod.exact(b'x', b'', files=[b'dir/subdir/foo.txt']) | m = matchmod.exact(files=[b'dir/subdir/foo.txt']) | ||||
| assert isinstance(m, matchmod.exactmatcher) | assert isinstance(m, matchmod.exactmatcher) | ||||
| self.assertTrue(m.visitdir(b'.')) | self.assertTrue(m.visitdir(b'.')) | ||||
| self.assertTrue(m.visitdir(b'dir')) | self.assertTrue(m.visitdir(b'dir')) | ||||
| self.assertTrue(m.visitdir(b'dir/subdir')) | self.assertTrue(m.visitdir(b'dir/subdir')) | ||||
| self.assertFalse(m.visitdir(b'dir/subdir/foo.txt')) | self.assertFalse(m.visitdir(b'dir/subdir/foo.txt')) | ||||
| self.assertFalse(m.visitdir(b'dir/foo')) | self.assertFalse(m.visitdir(b'dir/foo')) | ||||
| self.assertFalse(m.visitdir(b'dir/subdir/x')) | self.assertFalse(m.visitdir(b'dir/subdir/x')) | ||||
| self.assertFalse(m.visitdir(b'folder')) | self.assertFalse(m.visitdir(b'folder')) | ||||
| def testVisitchildrenset(self): | def testVisitchildrenset(self): | ||||
| m = matchmod.exact(b'x', b'', files=[b'dir/subdir/foo.txt']) | m = matchmod.exact(files=[b'dir/subdir/foo.txt']) | ||||
| assert isinstance(m, matchmod.exactmatcher) | assert isinstance(m, matchmod.exactmatcher) | ||||
| self.assertEqual(m.visitchildrenset(b'.'), {b'dir'}) | self.assertEqual(m.visitchildrenset(b'.'), {b'dir'}) | ||||
| self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) | self.assertEqual(m.visitchildrenset(b'dir'), {b'subdir'}) | ||||
| self.assertEqual(m.visitchildrenset(b'dir/subdir'), {b'foo.txt'}) | self.assertEqual(m.visitchildrenset(b'dir/subdir'), {b'foo.txt'}) | ||||
| self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) | self.assertEqual(m.visitchildrenset(b'dir/subdir/x'), set()) | ||||
| self.assertEqual(m.visitchildrenset(b'dir/subdir/foo.txt'), set()) | self.assertEqual(m.visitchildrenset(b'dir/subdir/foo.txt'), set()) | ||||
| self.assertEqual(m.visitchildrenset(b'folder'), set()) | self.assertEqual(m.visitchildrenset(b'folder'), set()) | ||||
| def testVisitchildrensetFilesAndDirs(self): | def testVisitchildrensetFilesAndDirs(self): | ||||
| m = matchmod.exact(b'x', b'', files=[b'rootfile.txt', | m = matchmod.exact(files=[b'rootfile.txt', | ||||
| b'a/file1.txt', | b'a/file1.txt', | ||||
| b'a/b/file2.txt', | b'a/b/file2.txt', | ||||
| # no file in a/b/c | # no file in a/b/c | ||||
| b'a/b/c/d/file4.txt']) | b'a/b/c/d/file4.txt']) | ||||
| assert isinstance(m, matchmod.exactmatcher) | assert isinstance(m, matchmod.exactmatcher) | ||||
| self.assertEqual(m.visitchildrenset(b'.'), {b'a', b'rootfile.txt'}) | self.assertEqual(m.visitchildrenset(b'.'), {b'a', b'rootfile.txt'}) | ||||
| self.assertEqual(m.visitchildrenset(b'a'), {b'b', b'file1.txt'}) | self.assertEqual(m.visitchildrenset(b'a'), {b'b', b'file1.txt'}) | ||||
| self.assertEqual(m.visitchildrenset(b'a/b'), {b'c', b'file2.txt'}) | self.assertEqual(m.visitchildrenset(b'a/b'), {b'c', b'file2.txt'}) | ||||
| self.assertEqual(m.visitchildrenset(b'a/b/c'), {b'd'}) | self.assertEqual(m.visitchildrenset(b'a/b/c'), {b'd'}) | ||||
| self.assertEqual(m.visitchildrenset(b'a/b/c/d'), {b'file4.txt'}) | self.assertEqual(m.visitchildrenset(b'a/b/c/d'), {b'file4.txt'}) | ||||
| self.assertEqual(m.visitchildrenset(b'a/b/c/d/e'), set()) | self.assertEqual(m.visitchildrenset(b'a/b/c/d/e'), set()) | ||||
| self.assertEqual(m.visitchildrenset(b'folder'), set()) | self.assertEqual(m.visitchildrenset(b'folder'), set()) | ||||