( )⚙ 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
Lint Skipped
Unit
Unit Tests Skipped

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 5508

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