( )⚙ D2192 narrow: make restrictpatterns a little more idiomatic

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2192

narrow: make restrictpatterns a little more idiomatic
ClosedPublic

Authored by durin42 on Feb 12 2018, 3:03 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG8fd0a9e2d7e9: narrow: make restrictpatterns a little more idiomatic
Summary

I'm not sure why invalid_includes was an out-param, but it doesn't
look like there's any reason for it to be now.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durin42 created this revision.Feb 12 2018, 3:03 PM
indygreg accepted this revision.Feb 12 2018, 5:55 PM
This revision is now accepted and ready to land.Feb 12 2018, 5:55 PM
Closed by commit rHG8fd0a9e2d7e9: narrow: make restrictpatterns a little more idiomatic (authored by durin42). · Explain WhyFeb 12 2018, 6:18 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 5562

hgext/narrow/narrowbundle2.py

user_includes = [ user_includes = [
'path:.' if p == '*' else 'path:' + p for p in user_includes] 'path:.' if p == '*' else 'path:' + p for p in user_includes]
user_excludes = [ user_excludes = [
'path:.' if p == '*' else 'path:' + p for p in user_excludes] 'path:.' if p == '*' else 'path:' + p for p in user_excludes]
req_includes = set(kwargs.get('includepats', [])) req_includes = set(kwargs.get('includepats', []))
req_excludes = set(kwargs.get('excludepats', [])) req_excludes = set(kwargs.get('excludepats', []))
invalid_includes = [] req_includes, req_excludes, invalid_includes = narrowspec.restrictpatterns(
req_includes, req_excludes = narrowspec.restrictpatterns( req_includes, req_excludes, user_includes, user_excludes)
req_includes, req_excludes,
user_includes, user_excludes, invalid_includes)
if invalid_includes: if invalid_includes:
raise error.Abort( raise error.Abort(
_("The following includes are not accessible for {}: {}") _("The following includes are not accessible for {}: {}")
.format(username, invalid_includes)) .format(username, invalid_includes))
new_args = {} new_args = {}
new_args.update(kwargs) new_args.update(kwargs)

hgext/narrow/narrowcommands.py

return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
def archivenarrowcmd(orig, ui, repo, *args, **opts): def archivenarrowcmd(orig, ui, repo, *args, **opts):
"""Wraps archive command to narrow the default includes.""" """Wraps archive command to narrow the default includes."""
if narrowrepo.REQUIREMENT in repo.requirements: if narrowrepo.REQUIREMENT in repo.requirements:
repo_includes, repo_excludes = repo.narrowpats repo_includes, repo_excludes = repo.narrowpats
includes = set(opts.get('include', [])) includes = set(opts.get('include', []))
excludes = set(opts.get('exclude', [])) excludes = set(opts.get('exclude', []))
includes, excludes = narrowspec.restrictpatterns( includes, excludes, unused_invalid = narrowspec.restrictpatterns(
includes, excludes, repo_includes, repo_excludes) includes, excludes, repo_includes, repo_excludes)
if includes: if includes:
opts['include'] = includes opts['include'] = includes
if excludes: if excludes:
opts['exclude'] = excludes opts['exclude'] = excludes
return orig(ui, repo, *args, **opts) return orig(ui, repo, *args, **opts)
def pullbundle2extraprepare(orig, pullop, kwargs): def pullbundle2extraprepare(orig, pullop, kwargs):

hgext/narrow/narrowspec.py

return _parsestoredpatterns(spec) return _parsestoredpatterns(spec)
def save(repo, includepats, excludepats): def save(repo, includepats, excludepats):
spec = format(includepats, excludepats) spec = format(includepats, excludepats)
if repo.shared(): if repo.shared():
repo = share._getsrcrepo(repo) repo = share._getsrcrepo(repo)
repo.vfs.write(FILENAME, spec) repo.vfs.write(FILENAME, spec)
def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes, def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes):
invalid_includes=None):
r""" Restricts the patterns according to repo settings, r""" Restricts the patterns according to repo settings,
results in a logical AND operation results in a logical AND operation
:param req_includes: requested includes :param req_includes: requested includes
:param req_excludes: requested excludes :param req_excludes: requested excludes
:param repo_includes: repo includes :param repo_includes: repo includes
:param repo_excludes: repo excludes :param repo_excludes: repo excludes
:param invalid_includes: an array to collect invalid includes :return: include patterns, exclude patterns, and invalid include patterns.
:return: include and exclude patterns
>>> restrictpatterns({'f1','f2'}, {}, ['f1'], []) >>> restrictpatterns({'f1','f2'}, {}, ['f1'], [])
(set(['f1']), {}) (set(['f1']), {}, [])
>>> restrictpatterns({'f1'}, {}, ['f1','f2'], []) >>> restrictpatterns({'f1'}, {}, ['f1','f2'], [])
(set(['f1']), {}) (set(['f1']), {}, [])
>>> restrictpatterns({'f1/fc1', 'f3/fc3'}, {}, ['f1','f2'], []) >>> restrictpatterns({'f1/fc1', 'f3/fc3'}, {}, ['f1','f2'], [])
(set(['f1/fc1']), {}) (set(['f1/fc1']), {}, [])
>>> restrictpatterns({'f1_fc1'}, {}, ['f1','f2'], []) >>> restrictpatterns({'f1_fc1'}, {}, ['f1','f2'], [])
([], set(['path:.'])) ([], set(['path:.']), [])
>>> restrictpatterns({'f1/../f2/fc2'}, {}, ['f1','f2'], []) >>> restrictpatterns({'f1/../f2/fc2'}, {}, ['f1','f2'], [])
(set(['f2/fc2']), {}) (set(['f2/fc2']), {}, [])
>>> restrictpatterns({'f1/../f3/fc3'}, {}, ['f1','f2'], []) >>> restrictpatterns({'f1/../f3/fc3'}, {}, ['f1','f2'], [])
([], set(['path:.'])) ([], set(['path:.']), [])
>>> restrictpatterns({'f1/$non_exitent_var'}, {}, ['f1','f2'], []) >>> restrictpatterns({'f1/$non_exitent_var'}, {}, ['f1','f2'], [])
(set(['f1/$non_exitent_var']), {}) (set(['f1/$non_exitent_var']), {}, [])
""" """
res_excludes = set(req_excludes) res_excludes = set(req_excludes)
res_excludes.update(repo_excludes) res_excludes.update(repo_excludes)
invalid_includes = []
if not req_includes: if not req_includes:
res_includes = set(repo_includes) res_includes = set(repo_includes)
elif 'path:.' not in repo_includes: elif 'path:.' not in repo_includes:
res_includes = [] res_includes = []
for req_include in req_includes: for req_include in req_includes:
req_include = util.expandpath(util.normpath(req_include)) req_include = util.expandpath(util.normpath(req_include))
if req_include in repo_includes: if req_include in repo_includes:
res_includes.append(req_include) res_includes.append(req_include)
continue continue
valid = False valid = False
for repo_include in repo_includes: for repo_include in repo_includes:
if req_include.startswith(repo_include + '/'): if req_include.startswith(repo_include + '/'):
valid = True valid = True
res_includes.append(req_include) res_includes.append(req_include)
break break
if not valid and invalid_includes is not None: if not valid:
invalid_includes.append(req_include) invalid_includes.append(req_include)
if len(res_includes) == 0: if len(res_includes) == 0:
res_excludes = {'path:.'} res_excludes = {'path:.'}
else: else:
res_includes = set(res_includes) res_includes = set(res_includes)
else: else:
res_includes = set(req_includes) res_includes = set(req_includes)
return res_includes, res_excludes return res_includes, res_excludes, invalid_includes