Exemple #1
0
    def test_demand_compile_regexp(self):
        scope = {}
        demandload.demand_compile_regexp('foo', 'frob', scope=scope)
        self.assertEqual(scope.keys(), ['foo'])
        self.assertEqual('frob', scope['foo'].pattern)
        self.assertEqual('frob', scope['foo'].pattern)

        # verify it's delayed via a bad regex.
        demandload.demand_compile_regexp('foo', 'f(', scope=scope)
        self.assertEqual(scope.keys(), ['foo'])
        # should blow up on accessing an attribute.
        obj = scope['foo']
        self.assertRaises(sre_constants.error, getattr, obj, 'pattern')
Exemple #2
0
    def test_demand_compile_regexp(self):
        scope = {}
        demandload.demand_compile_regexp(scope, 'foo', 'frob')
        self.assertEqual(scope.keys(), ['foo'])
        self.assertEqual('frob', scope['foo'].pattern)
        self.assertEqual('frob', scope['foo'].pattern)

        # verify it's delayed via a bad regex.
        demandload.demand_compile_regexp(scope, 'foo', 'f(')
        self.assertEqual(scope.keys(), ['foo'])
        # should blow up on accessing an attribute.
        obj = scope['foo']
        self.assertRaises(sre_constants.error, getattr, obj, 'pattern')
Exemple #3
0
    def test_demand_compile_regexp(self):
        scope = {}
        demandload.demand_compile_regexp('foo', 'frob', scope=scope)
        assert list(scope.keys()) == ['foo']
        assert 'frob' == scope['foo'].pattern
        assert 'frob' == scope['foo'].pattern

        # verify it's delayed via a bad regex.
        demandload.demand_compile_regexp('foo', 'f(', scope=scope)
        assert list(scope.keys()) == ['foo']
        # should blow up on accessing an attribute.
        obj = scope['foo']
        with pytest.raises(sre_constants.error):
            getattr(obj, 'pattern')
    def test_demand_compile_regexp(self):
        scope = {}
        demandload.demand_compile_regexp('foo', 'frob', scope=scope)
        assert list(scope.keys()) == ['foo']
        assert 'frob' == scope['foo'].pattern
        assert 'frob' == scope['foo'].pattern

        # verify it's delayed via a bad regex.
        demandload.demand_compile_regexp('foo', 'f(', scope=scope)
        assert list(scope.keys()) == ['foo']
        # should blow up on accessing an attribute.
        obj = scope['foo']
        with pytest.raises(sre_constants.error):
            getattr(obj, 'pattern')
Exemple #5
0
from itertools import chain
from tempfile import TemporaryDirectory

from pkgcore.ebuild.misc import sort_keywords
from pkgcore.ebuild.repository import UnconfiguredTree
from pkgcore.exceptions import PkgcoreException
from snakeoil.demandload import demand_compile_regexp
from snakeoil.klass import jit_attr
from snakeoil.osutils import pjoin
from snakeoil.strings import pluralism as _pl

from .. import base, git, results, sources
from ..log import logger
from . import ExplicitlyEnabledCheck, GentooRepoCheck

demand_compile_regexp('ebuild_copyright_regex',
                      r'^# Copyright (\d\d\d\d(-\d\d\d\d)?) .+')


class GitCommitsRepoSource(sources.RepoSource):
    """Repository source for locally changed packages in git history.

    Parses git log history to determine packages with changes that
    haven't been pushed upstream yet.
    """

    required_addons = (git.GitAddon, )

    def __init__(self, *args, git_addon):
        super().__init__(*args)
        self._repo = git_addon.commits_repo(git.GitChangedRepo)
Exemple #6
0
# License: GPL2/BSD
"""gentoo ebuild specific base package class"""

__all__ = ("CPV", "versioned_CPV", "unversioned_CPV")

from itertools import izip
from snakeoil.compatibility import cmp
from snakeoil.klass import inject_richcmp_methods_from_cmp
from pkgcore.ebuild.errors import InvalidCPV

from pkgcore.package import base
# do this to break the cycle.
from snakeoil.demandload import demandload, demand_compile_regexp
demandload(globals(), "pkgcore.ebuild:atom")

demand_compile_regexp(globals(), 'suffix_regexp',
                      '^(alpha|beta|rc|pre|p)(\\d*)$')
suffix_value = {"pre": -2, "p": 1, "alpha": -4, "beta": -3, "rc": -1}

# while the package section looks fugly, there is a reason for it-
# to prevent version chunks from showing up in the package

demand_compile_regexp(
    globals(), 'isvalid_version_re',
    r"^(?:\d+)(?:\.\d+)*[a-zA-Z]?(?:_(p(?:re)?|beta|alpha|rc)\d*)*$")

demand_compile_regexp(globals(), 'isvalid_cat_re',
                      r"^(?:[a-zA-Z0-9][-a-zA-Z0-9+._]*(?:/(?!$))?)+$")

demand_compile_regexp(
    globals(),
    '_pkg_re',
Exemple #7
0
Please note that while this functionality can do variable interpolation,
it strictly treats the source as non-executable code.  It cannot parse
subshells, variable additions, etc.

Its primary usage is for reading things like gentoo make.conf's, or
libtool .la files that are bash compatible, but non-executable.
"""

from shlex import shlex

from snakeoil.compatibility import raise_from
from snakeoil.demandload import demand_compile_regexp
from snakeoil.fileutils import readlines_utf8
from snakeoil.mappings import ProtectedDict

demand_compile_regexp('line_cont_regexp', r'^(.*[^\\]|)\\$')
demand_compile_regexp('inline_comment_regexp', r'^.*\s#.*$')
demand_compile_regexp('var_find', r'\\?(\${\w+}|\$\w+)')
demand_compile_regexp('backslash_find', r'\\.')

__all__ = (
    "iter_read_bash", "read_bash", "read_dict", "read_bash_dict",
    "bash_parser", "BashParseError")


def iter_read_bash(bash_source, allow_inline_comments=True,
                   allow_line_cont=False):
    """Iterate over a file honoring bash commenting rules and line continuations.

    Note that it's considered good behaviour to close filehandles, as
    such, either iterate fully through this, or use read_bash instead.
Exemple #8
0
import subprocess
import sys
from collections import defaultdict
from functools import partial
from weakref import WeakValueDictionary

from snakeoil import klass
from snakeoil.demandload import demand_compile_regexp
from snakeoil.mappings import ImmutableDict, OrderedFrozenSet, inject_getitem_as_getattr
from snakeoil.osutils import pjoin
from snakeoil.process.spawn import bash_version

from ..log import logger
from . import atom, const

demand_compile_regexp('_valid_EAPI_regex', r"^[A-Za-z0-9_][A-Za-z0-9+_.-]*$")

eapi_optionals = ImmutableDict({
    # Controls whether PROPERTIES and RESTRICT are accumulated across eclasses.
    "accumulate_properties_restrict":
    False,

    # Controls what version of bash compatibility to force; see PMS.
    "bash_compat":
    '3.2',

    # Controls whether -r is allowed for dodoc.
    "dodoc_allow_recursive":
    False,

    # Controls the language awareness of doman; see PMS.
Exemple #9
0
from pkgcore.restrictions import boolean, values
from pkgcore.restrictions.packages import AndRestriction

from snakeoil import klass
from snakeoil.compatibility import intern
from snakeoil.demandload import demandload, demand_compile_regexp
from snakeoil.mappings import IndeterminantDict

demandload(
    "snakeoil:chksum",
    "snakeoil:data_source,fileutils",
    "pkgcore.ebuild.eapi:get_eapi",
    "pkgcore.log:logger",
)

demand_compile_regexp('_parse_EAPI_RE',
                      r"^EAPI=(['\"]?)([A-Za-z0-9+_.-]*)\1[\t ]*(?:#.*)?")


def generate_depset(c, key, non_package_type, s, **kwds):
    if non_package_type:
        return conditionals.DepSet.parse(s.data.pop(key, ""),
                                         c,
                                         operators={
                                             "||": boolean.OrRestriction,
                                             "": boolean.AndRestriction
                                         },
                                         **kwds)
    eapi_obj = s.eapi_obj
    if not eapi_obj.is_supported:
        raise metadata_errors.MetadataException(
            s, "eapi", "unsupported eapi: %s" % eapi_obj.magic)
Exemple #10
0
from pkgcore.restrictions import boolean, values

from snakeoil import klass
from snakeoil.demandload import demandload, demand_compile_regexp

demandload(
    "snakeoil:chksum",
    "snakeoil:data_source,fileutils",
    'snakeoil.sequences:iflatten_instance',
    "pkgcore.ebuild:const",
    "pkgcore.ebuild.eapi:get_eapi",
    "pkgcore:fetch",
    "pkgcore.log:logger",
)

demand_compile_regexp('_parse_EAPI_regex',
                      r"^EAPI=(['\"]?)([A-Za-z0-9+_.-]*)\1[\t ]*(?:#.*)?")
demand_compile_regexp('_parse_inherit_regex', r'^\s*inherit\s(.*)$')


def generate_depset(kls, key, non_package_type, self, **kwds):
    if non_package_type:
        return conditionals.DepSet.parse(self.data.pop(key, ""),
                                         kls,
                                         operators={
                                             "||": boolean.OrRestriction,
                                             "": boolean.AndRestriction
                                         },
                                         **kwds)
    kwds['element_func'] = self.eapi.atom_kls
    kwds['transitive_use_atoms'] = self.eapi.options.transitive_use_atoms
    return conditionals.DepSet.parse(self.data.pop(key, ""), kls, **kwds)
Exemple #11
0
from snakeoil.demandload import demand_compile_regexp
from snakeoil.iterables import partition
from snakeoil.klass import jit_attr
from snakeoil.osutils import pjoin
from snakeoil.process import CommandNotFound, find_binary
from snakeoil.process.spawn import spawn_get_output
from snakeoil.strings import pluralism

from . import base, caches, objects
from .checks import GitCheck
from .log import logger

# hacky path regexes for git log parsing, proper validation is handled later
_ebuild_path_regex_raw = '([^/]+)/([^/]+)/([^/]+)\\.ebuild'
_ebuild_path_regex = '(?P<category>[^/]+)/(?P<PN>[^/]+)/(?P<P>[^/]+)\\.ebuild'
demand_compile_regexp('ebuild_ADM_regex',
                      fr'^(?P<status>[ADM])\t{_ebuild_path_regex}$')
demand_compile_regexp(
    'ebuild_R_regex',
    fr'^(?P<status>R)\d+\t{_ebuild_path_regex}\t{_ebuild_path_regex_raw}$')
demand_compile_regexp('eclass_regex', r'^eclass/(?P<eclass>\S+)\.eclass$')


class GitCommit:
    """Git commit objects."""
    def __init__(self, hash, commit_date, author, committer, message):
        self.hash = hash
        self.commit_date = commit_date
        self.author = author
        self.committer = committer
        self.message = message
Exemple #12
0
Please note that while this functionality can do variable interpolation,
it strictly treats the source as non-executable code.  It cannot parse
subshells, variable additions, etc.

Its primary usage is for reading things like gentoo make.conf's, or
libtool .la files that are bash compatible, but non executable.
"""

from shlex import shlex

from snakeoil.compatibility import raise_from
from snakeoil.demandload import demand_compile_regexp
from snakeoil.fileutils import readlines_utf8
from snakeoil.mappings import ProtectedDict

demand_compile_regexp('line_cont_regexp', r'^(.*[^\\]|)\\$')
demand_compile_regexp('inline_comment_regexp', r'^.*\s#.*$')
demand_compile_regexp('var_find', r'\\?(\${\w+}|\$\w+)')
demand_compile_regexp('backslash_find', r'\\.')

__all__ = (
    "iter_read_bash", "read_bash", "read_dict", "read_bash_dict",
    "bash_parser", "BashParseError")


def iter_read_bash(bash_source, allow_inline_comments=True,
                   allow_line_cont=False):
    """Iterate over a file honoring bash commenting rules and line continuations.

    Note that it's considered good behaviour to close filehandles, as
    such, either iterate fully through this, or use read_bash instead.
Exemple #13
0
from pkgcore.fetch.errors import UnknownMirror
from pkgcore.fetch import fetchable, mirror, uri_list, default_mirror
from pkgcore.ebuild import processor

from snakeoil.mappings import IndeterminantDict
from snakeoil.currying import alias_class_method, partial
from snakeoil import klass
from snakeoil.compatibility import intern

from snakeoil import demandload

demandload.demandload(
    globals(), "pkgcore.log:logger", "pkgcore.ebuild.eapi:get_eapi", "snakeoil:data_source,fileutils", "snakeoil:chksum"
)

demandload.demand_compile_regexp(globals(), "_parse_EAPI_RE", r"^EAPI=(['\"]?)([A-Za-z0-9+_.-]*)\1[\t ]*(?:#.*)?")


def generate_depset(c, key, non_package_type, s, **kwds):
    if non_package_type:
        return conditionals.DepSet.parse(
            s.data.pop(key, ""), c, operators={"||": boolean.OrRestriction, "": boolean.AndRestriction}, **kwds
        )
    eapi_obj = s.eapi_obj
    if not eapi_obj.is_supported:
        raise metadata_errors.MetadataException(s, "eapi", "unsupported eapi: %s" % eapi_obj.magic)
    kwds["element_func"] = eapi_obj.atom_kls
    kwds["transitive_use_atoms"] = eapi_obj.options.transitive_use_atoms
    return conditionals.DepSet.parse(s.data.pop(key, ""), c, **kwds)

Exemple #14
0
# namespace compatibility...
MalformedAtom = errors.MalformedAtom

alphanum = set(string.digits)
alphanum.update(string.ascii_letters)

valid_repo_chars = set(alphanum)
valid_repo_chars.update("_-")
valid_slot_chars = set(alphanum)
valid_slot_chars.update(".+_-")
alphanum = frozenset(alphanum)
valid_repo_chars = frozenset(valid_repo_chars)
valid_slot_chars = frozenset(valid_slot_chars)
valid_ops = frozenset(['<', '<=', '=', '~', '>=', '>'])

demand_compile_regexp('valid_use_flag', r'^[A-Za-z0-9][A-Za-z0-9+_@-]*$')


class atom(boolean.AndRestriction, metaclass=klass.generic_equality):
    """Currently implements gentoo ebuild atom parsing.

    Should be converted into an agnostic dependency base.
    """

    # note we don't need _hash
    __slots__ = (
        "blocks",
        "blocks_strongly",
        "op",
        "cpvstr",
        "negate_vers",
Exemple #15
0
from collections import defaultdict, deque
from operator import itemgetter

from snakeoil.demandload import demand_compile_regexp
from snakeoil.osutils import listdir_files, pjoin
from snakeoil.sequences import iflatten_instance

from ..log import logger
from .atom import atom

demand_compile_regexp('valid_updates_re', r'^([1-4])Q-(\d{4})$')


def _scan_directory(path):
    files = []
    for filename in listdir_files(path):
        match = valid_updates_re.match(filename)
        if match is not None:
            files.append(((match.group(2), match.group(1)), filename))
        else:
            logger.error(f'incorrectly named update file: {filename!r}')
    files.sort(key=itemgetter(0))
    return [x[1] for x in files]


def read_updates(path):
    def f():
        d = deque()
        return [d,d]
    # mods tracks the start point [0], and the tail, [1].
    # via this, pkg moves into a specific pkg can pick up
Exemple #16
0
# Copyright: 2006 Markus Ullmann <*****@*****.**>
# Copyright: 2006 Marien Zwart <*****@*****.**>
# License: BSD/GPL2

from snakeoil.demandload import demand_compile_regexp

from pkgcheck import base

demand_compile_regexp("indent_regexp", "^\t* \t+")


class base_whitespace(base.Warning):

    threshold = base.versioned_feed

    __slots__ = ()

    @property
    def lines_str(self):
        if len(self.lines) == 1:
            return "line %i" % self.lines[0]
        return "lines %s" % ", ".join(str(x) for x in self.lines)


class WhitespaceFound(base_whitespace):
    """leading or trailing whitespaces are found"""

    __slots__ = ("category", "package", "version", "lines", "leadtrail")

    def __init__(self, pkg, leadtrail, lines):
        super(WhitespaceFound, self).__init__()
Exemple #17
0
from pkgcore.restrictions import packages
from snakeoil.cli.exceptions import UserException
from snakeoil.demandload import demand_compile_regexp
from snakeoil.klass import jit_attr
from snakeoil.osutils import pjoin
from snakeoil.process import CommandNotFound, find_binary
from snakeoil.process.spawn import spawn_get_output
from snakeoil.strings import pluralism as _pl

from . import base
from .log import logger

# hacky ebuild path regexes for git log parsing, proper atom validation is handled later
_ebuild_path_regex_raw = '([^/]+)/([^/]+)/([^/]+)\\.ebuild'
_ebuild_path_regex = '(?P<category>[^/]+)/(?P<PN>[^/]+)/(?P<P>[^/]+)\\.ebuild'
demand_compile_regexp('ebuild_ADM_regex',
                      fr'^(?P<status>[ADM])\t{_ebuild_path_regex}$')
demand_compile_regexp(
    'ebuild_R_regex',
    fr'^(?P<status>R)\d+\t{_ebuild_path_regex_raw}\t{_ebuild_path_regex}$')

_GitCommit = namedtuple(
    'GitCommit', ['commit', 'commit_date', 'author', 'committer', 'message'])
_GitPkgChange = namedtuple('GitPkgChange', [
    'atom', 'status', 'commit', 'commit_date', 'author', 'committer', 'message'
])


class ParsedGitRepo(UserDict):
    """Parse repository git logs."""

    # git command to run on the targeted repo
Exemple #18
0
import re
import sys

from snakeoil import mappings, weakrefs, klass
from snakeoil.demandload import demandload, demand_compile_regexp
from snakeoil.osutils import pjoin

demandload(
    "functools:partial",
    'snakeoil.process.spawn:bash_version,spawn_get_output',
    "pkgcore.ebuild:atom,const",
    "pkgcore.log:logger",
)

demand_compile_regexp(
    '_valid_EAPI_regex', r"^[A-Za-z0-9_][A-Za-z0-9+_.-]*$"
)


eapi_optionals = mappings.ImmutableDict({
    # Controls what version of bash compatibility to force; see PMS.
    "bash_compat": '3.2',

    # Controls whether -r is allowed for dodoc.
    "dodoc_allow_recursive": False,

    # Controls the language awareness of doman; see PMS.
    "doman_language_detect": False,

    # Controls whether -i18n option is allowed.
    "doman_language_override": False,
Exemple #19
0
# License: GPL2/BSD 3 clause

from collections import deque, defaultdict
from operator import itemgetter

from snakeoil.demandload import demandload, demand_compile_regexp
from snakeoil.fileutils import readlines
from snakeoil.osutils import listdir_files, pjoin
from snakeoil.sequences import iflatten_instance

from pkgcore.ebuild.atom import atom

demandload('pkgcore.log:logger')

demand_compile_regexp(
    "valid_updates_re", "^(\d)Q-(\d{4})$"
)


def _scan_directory(path):
    files = []
    for x in listdir_files(path):
        match = valid_updates_re.match(x)
        if match is not None:
            files.append(((match.group(2), match.group(1)), x))
    files.sort(key=itemgetter(0))
    return [x[1] for x in files]


def read_updates(path):
    def f():
Exemple #20
0
import re
from collections import defaultdict

from pkgcore.ebuild.eapi import EAPI
from snakeoil.demandload import demand_compile_regexp
from snakeoil.klass import jit_attr
from snakeoil.mappings import ImmutableDict
from snakeoil.sequences import stable_unique
from snakeoil.strings import pluralism as _pl

from .. import results, sources
from . import Check, GentooRepoCheck

demand_compile_regexp(
    'ebuild_copyright_regex',
    r'^# Copyright (?P<begin>\d{4}-)?(?P<end>\d{4}) (?P<holder>.+)$')

PREFIXED_VARIABLES = ('EROOT', 'ED')
PATH_VARIABLES = ('BROOT', 'ROOT', 'D') + PREFIXED_VARIABLES


class _CommandResult(results.LineResult):
    """Generic command result."""
    def __init__(self, command, **kwargs):
        super().__init__(**kwargs)
        self.command = command

    @property
    def usage_desc(self):
        return f'{self.command!r}'
Exemple #21
0
from pkgcore.package.errors import MissingChksum
from pkgcore.restrictions import boolean, values

from snakeoil import klass
from snakeoil.compatibility import intern
from snakeoil.demandload import demandload, demand_compile_regexp

demandload(
    "snakeoil:chksum",
    "snakeoil:data_source,fileutils",
    "pkgcore.ebuild.eapi:get_eapi",
    "pkgcore.log:logger",
)

demand_compile_regexp(
    '_parse_EAPI_RE', r"^EAPI=(['\"]?)([A-Za-z0-9+_.-]*)\1[\t ]*(?:#.*)?"
)


def generate_depset(c, key, non_package_type, s, **kwds):
    if non_package_type:
        return conditionals.DepSet.parse(
            s.data.pop(key, ""), c,
            operators={
                "||":boolean.OrRestriction,
                "":boolean.AndRestriction},
            **kwds)
    eapi = s.eapi
    if not eapi.is_supported:
        raise metadata_errors.MetadataException(s, "eapi", "unsupported EAPI: %s" % (eapi,))
    kwds['element_func'] = eapi.atom_kls
Exemple #22
0
# License: GPL2/BSD 3 clause

from operator import itemgetter
from collections import deque, defaultdict
from snakeoil.osutils import listdir_files, pjoin
from snakeoil.fileutils import readlines
from pkgcore.ebuild.atom import atom
from snakeoil.lists import iflatten_instance
from snakeoil import demandload

demandload.demandload(
    globals(),
    'pkgcore.log:logger',
)

demandload.demand_compile_regexp(globals(), "valid_updates_re",
                                 "^(\d)Q-(\d{4})$")


def _scan_directory(path):
    files = []
    for x in listdir_files(path):
        match = valid_updates_re.match(x)
        if match is not None:
            files.append(((match.group(2), match.group(1)), x))
    files.sort(key=itemgetter(0))
    return [x[1] for x in files]


def read_updates(path):
    def f():
        d = deque()
Exemple #23
0
__all__ = ("CPV", "versioned_CPV", "unversioned_CPV")

from itertools import izip

from snakeoil.compatibility import cmp
from snakeoil.demandload import demandload, demand_compile_regexp
from snakeoil.klass import inject_richcmp_methods_from_cmp

from pkgcore.ebuild.errors import InvalidCPV
from pkgcore.package import base

# do this to break the cycle.
demandload("pkgcore.ebuild:atom")

demand_compile_regexp(
    'suffix_regexp', '^(alpha|beta|rc|pre|p)(\\d*)$')

suffix_value = {"pre": -2, "p": 1, "alpha": -4, "beta": -3, "rc": -1}

# while the package section looks fugly, there is a reason for it-
# to prevent version chunks from showing up in the package

demand_compile_regexp(
    'isvalid_version_re',
    r"^(?:\d+)(?:\.\d+)*[a-zA-Z]?(?:_(p(?:re)?|beta|alpha|rc)\d*)*$")

demand_compile_regexp(
    'isvalid_cat_re', r"^(?:[a-zA-Z0-9][-a-zA-Z0-9+._]*(?:/(?!$))?)+$")

# empty string is fine, means a -- was encounter.
demand_compile_regexp(
Exemple #24
0
# License: GPL2/BSD 3 clause

from collections import deque, defaultdict
from operator import itemgetter

from snakeoil.demandload import demandload, demand_compile_regexp
from snakeoil.fileutils import readlines
from snakeoil.osutils import listdir_files, pjoin
from snakeoil.sequences import iflatten_instance

from pkgcore.ebuild.atom import atom

demandload('pkgcore.log:logger')

demand_compile_regexp(
    "valid_updates_re", "^(\d)Q-(\d{4})$"
)


def _scan_directory(path):
    files = []
    for x in listdir_files(path):
        match = valid_updates_re.match(x)
        if match is not None:
            files.append(((match.group(2), match.group(1)), x))
    files.sort(key=itemgetter(0))
    return [x[1] for x in files]

def read_updates(path):
    def f():
        d = deque()
Exemple #25
0
# License: GPL2/BSD
"""gentoo ebuild specific base package class"""

__all__ = ("CPV", "versioned_CPV", "unversioned_CPV")

from snakeoil.compatibility import cmp
from snakeoil.demandload import demandload, demand_compile_regexp
from snakeoil.klass import inject_richcmp_methods_from_cmp

from pkgcore.ebuild.errors import InvalidCPV
from pkgcore.package import base

# do this to break the cycle.
demandload("pkgcore.ebuild:atom")

demand_compile_regexp('suffix_regexp', '^(alpha|beta|rc|pre|p)(\\d*)$')

suffix_value = {"pre": -2, "p": 1, "alpha": -4, "beta": -3, "rc": -1}

# while the package section looks fugly, there is a reason for it-
# to prevent version chunks from showing up in the package

demand_compile_regexp(
    'isvalid_version_re',
    r"^(?:\d+)(?:\.\d+)*[a-zA-Z]?(?:_(p(?:re)?|beta|alpha|rc)\d*)*$")

demand_compile_regexp('isvalid_cat_re',
                      r"^(?:[a-zA-Z0-9][-a-zA-Z0-9+._]*(?:/(?!$))?)+$")

# empty string is fine, means a -- was encounter.
demand_compile_regexp('_pkg_re', r"^[a-zA-Z0-9+_]+$")
Exemple #26
0
"""gentoo ebuild specific base package class"""

__all__ = ("CPV", "versioned_CPV", "unversioned_CPV")

from itertools import izip
from snakeoil.compatibility import cmp
from snakeoil.klass import inject_richcmp_methods_from_cmp
from pkgcore.ebuild.errors import InvalidCPV

from pkgcore.package import base
# do this to break the cycle.
from snakeoil.demandload import demandload, demand_compile_regexp
demandload(globals(), "pkgcore.ebuild:atom")

demand_compile_regexp(globals(), 'suffix_regexp',
    '^(alpha|beta|rc|pre|p)(\\d*)$')
suffix_value = {"pre": -2, "p": 1, "alpha": -4, "beta": -3, "rc": -1}

# while the package section looks fugly, there is a reason for it-
# to prevent version chunks from showing up in the package

demand_compile_regexp(globals(), 'isvalid_version_re',
    r"^(?:\d+)(?:\.\d+)*[a-zA-Z]?(?:_(p(?:re)?|beta|alpha|rc)\d*)*$")

demand_compile_regexp(globals(), 'isvalid_cat_re',
    r"^(?:[a-zA-Z0-9][-a-zA-Z0-9+._]*(?:/(?!$))?)+$")

demand_compile_regexp(globals(), '_pkg_re',
    #empty string is fine, means a -- was encounter.
    r"^[a-zA-Z0-9+_]+$")
Exemple #27
0
from .. import fetch
from ..cache import errors as cache_errors
from ..log import logger
from ..package import errors as metadata_errors
from ..package import metadata
from ..package.base import DynamicGetattrSetter
from ..restrictions import boolean, values
from . import conditionals
from . import errors as ebuild_errors
from . import processor
from .atom import atom
from .eapi import get_eapi
from .misc import sort_keywords

demand_compile_regexp(
    '_EAPI_regex', r"^EAPI=(['\"]?)(?P<EAPI>[A-Za-z0-9+_.-]*)\1[\t ]*(?:#.*)?")
demand_compile_regexp('_EAPI_str_regex', r"^EAPI=(['\"]?)(?P<EAPI>.*)\1")


class base(metadata.package):
    """ebuild package

    :cvar _config_wrappables: mapping of attribute to callable for
        re-evaluating attributes dependent on configuration
    """

    _config_wrappables = {
        x: klass.alias_method("evaluate_depset")
        for x in (
            "bdepend",
            "depend",
Exemple #28
0
Please note that while this functionality can do variable interpolation,
it strictly treats the source as non-executable code.  It cannot parse
subshells, variable additions, etc.

Its primary usage is for reading things like gentoo make.conf's, or
libtool .la files that are bash compatible, but non executable.
"""

from shlex import shlex

from snakeoil.compatibility import raise_from
from snakeoil.demandload import demand_compile_regexp
from snakeoil.fileutils import readlines_utf8
from snakeoil.mappings import ProtectedDict

demand_compile_regexp("line_cont_regexp", r"^(.*[^\\]|)\\$")
demand_compile_regexp("inline_comment_regexp", r"^.*\s#.*$")
demand_compile_regexp("var_find", r"\\?(\${\w+}|\$\w+)")
demand_compile_regexp("backslash_find", r"\\.")

__all__ = ("iter_read_bash", "read_bash", "read_dict", "read_bash_dict", "bash_parser", "BashParseError")


def iter_read_bash(bash_source, allow_inline_comments=True, allow_line_cont=False):
    """Iterate over a file honoring bash commenting rules and line continuations.

    Note that it's considered good behaviour to close filehandles, as
    such, either iterate fully through this, or use read_bash instead.
    Once the file object is no longer referenced the handle will be
    closed, but be proactive instead of relying on the garbage
    collector.
Exemple #29
0
from tempfile import TemporaryDirectory
from urllib.parse import urlparse

from pkgcore.ebuild.misc import sort_keywords
from pkgcore.ebuild.repository import UnconfiguredTree
from pkgcore.exceptions import PkgcoreException
from snakeoil import klass
from snakeoil.demandload import demand_compile_regexp
from snakeoil.osutils import pjoin
from snakeoil.strings import pluralism

from .. import base, git, results, sources
from ..log import logger
from . import GentooRepoCheck, GitCheck

demand_compile_regexp('copyright_regex',
                      r'^# Copyright (\d\d\d\d(-\d\d\d\d)?) .+')

demand_compile_regexp('commit_footer',
                      r'^(?P<tag>[a-zA-Z0-9_-]+): (?P<value>.*)$')

demand_compile_regexp('git_cat_file_regex',
                      r'^(?P<object>.+?) (?P<status>.+)$')


class GitCommitsRepoSource(sources.RepoSource):
    """Repository source for locally changed packages in git history.

    Parses git log history to determine packages with changes that
    haven't been pushed upstream yet.
    """
Exemple #30
0
from snakeoil import chksum, data_source, fileutils, klass
from snakeoil.demandload import demand_compile_regexp
from snakeoil.sequences import iflatten_instance

from pkgcore import fetch
from pkgcore.cache import errors as cache_errors
from pkgcore.ebuild import conditionals, const, processor, errors as ebuild_errors
from pkgcore.ebuild.atom import atom
from pkgcore.ebuild.eapi import get_eapi
from pkgcore.ebuild.misc import sort_keywords
from pkgcore.log import logger
from pkgcore.package import errors as metadata_errors, metadata
from pkgcore.restrictions import boolean, values


demand_compile_regexp(
    '_EAPI_regex', r"^EAPI=(['\"]?)(?P<EAPI>[A-Za-z0-9+_.-]*)\1[\t ]*(?:#.*)?")
demand_compile_regexp(
    '_EAPI_str_regex', r"^EAPI=(['\"]?)(?P<EAPI>.*)\1")
demand_compile_regexp('_parse_inherit_regex', r'^\s*inherit\s(?P<eclasses>.*?)(#.*)?$')


def generate_depset(kls, key, self):
    return conditionals.DepSet.parse(
        self.data.pop(key, ""), kls,
        attr=key, element_func=self.eapi.atom_kls,
        transitive_use_atoms=self.eapi.options.transitive_use_atoms)


def generate_licenses(self):
    return conditionals.DepSet.parse(
        self.data.pop('LICENSE', ''), str,
Exemple #31
0
from snakeoil.demandload import demand_compile_regexp
from snakeoil.strings import pluralism as _pl

from .. import results, sources
from . import Check

demand_compile_regexp('indent_regexp', '^\t* \t+')


class _Whitespace(results.VersionResult, results.Warning):
    @property
    def lines_str(self):
        return f"line{_pl(self.lines)}: {', '.join(str(x) for x in self.lines)}"


class WhitespaceFound(_Whitespace):
    """Leading or trailing whitespace found."""
    def __init__(self, leadtrail, lines, **kwargs):
        super().__init__(**kwargs)
        self.lines = tuple(lines)
        self.leadtrail = leadtrail

    @property
    def desc(self):
        return f"ebuild has {self.leadtrail} whitespace on {self.lines_str}"


class WrongIndentFound(_Whitespace):
    """Incorrect indentation whitespace found."""
    def __init__(self, lines, **kwargs):
        super().__init__(**kwargs)
Exemple #32
0
# Copyright: 2011 Brian Harring <*****@*****.**>
# License: GPL2/BSD 3 clause

from operator import itemgetter
from collections import deque, defaultdict
from snakeoil.osutils import listdir_files, pjoin
from snakeoil.fileutils import readlines
from snakeoil.iterables import chain_from_iterable
from pkgcore.ebuild.atom import atom
from snakeoil.lists import iflatten_instance
from snakeoil import demandload
demandload.demandload(globals(),
    'pkgcore.log:logger',
)

demandload.demand_compile_regexp(globals(), "valid_updates_re", "^(\d)Q-(\d{4})$")


def _scan_directory(path):
    files = []
    for x in listdir_files(path):
        match = valid_updates_re.match(x)
        if match is not None:
            files.append(((match.group(2), match.group(1)), x))
    files.sort(key=itemgetter(0))
    return [x[1] for x in files]

def read_updates(path):
    def f():
        d = deque()
        return [d,d]
Exemple #33
0
from snakeoil import klass
from snakeoil.demandload import demandload, demand_compile_regexp

demandload(
    "snakeoil:chksum",
    "snakeoil:data_source,fileutils",
    'snakeoil.sequences:iflatten_instance',
    "pkgcore.ebuild:const",
    "pkgcore.ebuild.eapi:get_eapi",
    "pkgcore:fetch",
    "pkgcore.log:logger",
)

demand_compile_regexp(
    '_parse_EAPI_regex', r"^EAPI=(['\"]?)([A-Za-z0-9+_.-]*)\1[\t ]*(?:#.*)?"
)
demand_compile_regexp('_parse_inherit_regex', r'^\s*inherit\s(.*)$')


def generate_depset(kls, key, non_package_type, self, **kwds):
    if non_package_type:
        return conditionals.DepSet.parse(
            self.data.pop(key, ""), kls,
            operators={
                "||": boolean.OrRestriction,
                "": boolean.AndRestriction},
            **kwds)
    kwds['element_func'] = self.eapi.atom_kls
    kwds['transitive_use_atoms'] = self.eapi.options.transitive_use_atoms
    return conditionals.DepSet.parse(self.data.pop(key, ""), kls, **kwds)