# 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