# narrowspec.py - methods for working with a narrow view of a repository
#
# Copyright 2017 Google, Inc.
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from __future__ import absolute_import
import errno
from .i18n import _
from . import (
error,
match as matchmod,
util,
)
FILENAME = 'narrowspec'
def _parsestoredpatterns(text):
"""Parses the narrowspec format that's stored on disk."""
patlist = None
includepats = []
excludepats = []
for l in text.splitlines():
if l == '[includes]':
if patlist is None:
patlist = includepats
else:
raise error.Abort(_('narrowspec includes section must appear '
'at most once, before excludes'))
elif l == '[excludes]':
if patlist is not excludepats:
patlist = excludepats
else:
raise error.Abort(_('narrowspec excludes section must appear '
'at most once'))
else:
patlist.append(l)
return set(includepats), set(excludepats)
def parseserverpatterns(text):
"""Parses the narrowspec format that's returned by the server."""
includepats = set()
excludepats = set()
# We get one entry per line, in the format "<key> <value>".
# It's OK for value to contain other spaces.
for kp in (l.split(' ', 1) for l in text.splitlines()):
if len(kp) != 2:
raise error.Abort(_('Invalid narrowspec pattern line: "%s"') % kp)
key = kp[0]
pat = kp[1]
if key == 'include':
includepats.add(pat)
elif key == 'exclude':
excludepats.add(pat)
else:
raise error.Abort(_('Invalid key "%s" in server response') % key)
return includepats, excludepats
def normalizesplitpattern(kind, pat):
"""Returns the normalized version of a pattern and kind.
Returns a tuple with the normalized kind and normalized pattern.
"""
pat = pat.rstrip('/')
_validatepattern(pat)
return kind, pat
def _numlines(s):
"""Returns the number of lines in s, including ending empty lines."""
# We use splitlines because it is Unicode-friendly and thus Python 3
# compatible. However, it does not count empty lines at the end, so trick
# it by adding a character at the end.
return len((s + 'x').splitlines())
def _validatepattern(pat):
"""Validates the pattern and aborts if it is invalid.
Patterns are stored in the narrowspec as newline-separated
POSIX-style bytestring paths. There's no escaping.
"""
# We use newlines as separators in the narrowspec file, so don't allow them
# in patterns.
if _numlines(pat) > 1:
raise error.Abort(_('newlines are not allowed in narrowspec paths'))
components = pat.split('/')
if '.' in components or '..' in components:
raise error.Abort(_('"." and ".." are not allowed in narrowspec paths'))
def normalizepattern(pattern, defaultkind='path'):
"""Returns the normalized version of a text-format pattern.
If the pattern has no kind, the default will be added.
"""
kind, pat = matchmod._patsplit(pattern, defaultkind)
return '%s:%s' % normalizesplitpattern(kind, pat)
def parsepatterns(pats):
"""Parses a list of patterns into a typed pattern set."""
return set(normalizepattern(p) for p in pats)
def format(includes, excludes):
output = '[includes]\n'
for i in sorted(includes - excludes):
output += i + '\n'
output += '[excludes]\n'
for e in sorted(excludes):
output += e + '\n'
return output
def match(root, include=None, exclude=None):
if not include:
# Passing empty include and empty exclude to matchmod.match()
# gives a matcher that matches everything, so explicitly use
# the nevermatcher.
return matchmod.never(root, '')
return matchmod.match(root, '', [], include=include or [],
exclude=exclude or [])
def needsexpansion(includes):
return [i for i in includes if i.startswith('include:')]
def load(repo):
try:
spec = repo.vfs.read(FILENAME)
except IOError as e:
# Treat "narrowspec does not exist" the same as "narrowspec file exists
# and is empty".
if e.errno == errno.ENOENT:
# Without this the next call to load will use the cached
# non-existence of the file, which can cause some odd issues.
repo.invalidate(clearfilecache=True)
return set(), set()
raise
return _parsestoredpatterns(spec)
def save(repo, includepats, excludepats):
spec = format(includepats, excludepats)
repo.vfs.write(FILENAME, spec)
def restrictpatterns(req_includes, req_excludes, repo_includes, repo_excludes):
r""" Restricts the patterns according to repo settings,
results in a logical AND operation
:param req_includes: requested includes
:param req_excludes: requested excludes
:param repo_includes: repo includes
:param repo_excludes: repo excludes
:return: include patterns, exclude patterns, and invalid include patterns.
>>> restrictpatterns({'f1','f2'}, {}, ['f1'], [])
(set(['f1']), {}, [])
>>> restrictpatterns({'f1'}, {}, ['f1','f2'], [])
(set(['f1']), {}, [])
>>> restrictpatterns({'f1/fc1', 'f3/fc3'}, {}, ['f1','f2'], [])
(set(['f1/fc1']), {}, [])
>>> restrictpatterns({'f1_fc1'}, {}, ['f1','f2'], [])
([], set(['path:.']), [])
>>> restrictpatterns({'f1/../f2/fc2'}, {}, ['f1','f2'], [])
(set(['f2/fc2']), {}, [])
>>> restrictpatterns({'f1/../f3/fc3'}, {}, ['f1','f2'], [])
([], set(['path:.']), [])
>>> restrictpatterns({'f1/$non_exitent_var'}, {}, ['f1','f2'], [])
(set(['f1/$non_exitent_var']), {}, [])
"""
res_excludes = set(req_excludes)
res_excludes.update(repo_excludes)
invalid_includes = []
if not req_includes:
res_includes = set(repo_includes)
elif 'path:.' not in repo_includes:
res_includes = []
for req_include in req_includes:
req_include = util.expandpath(util.normpath(req_include))
if req_include in repo_includes:
res_includes.append(req_include)
continue
valid = False
for repo_include in repo_includes:
if req_include.startswith(repo_include + '/'):
valid = True
res_includes.append(req_include)
break
if not valid:
invalid_includes.append(req_include)
if len(res_includes) == 0:
res_excludes = {'path:.'}
else:
res_includes = set(res_includes)
else:
res_includes = set(req_includes)
return res_includes, res_excludes, invalid_includes