├── test
    ├── __init__.py
    ├── test_main.py
    ├── test_config.py
    ├── test_pm.py
    └── test_mangle.py
├── .gitignore
├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── ci.yaml
├── flaggie
    ├── __init__.py
    ├── config.py
    ├── pm.py
    ├── __main__.py
    └── mangle.py
├── tox.ini
├── COPYING
└── pyproject.toml


/test/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__/
2 | /.tox/
3 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | ko_fi: mgorny
2 | github: [mgorny]
3 | 


--------------------------------------------------------------------------------
/flaggie/__init__.py:
--------------------------------------------------------------------------------
1 | """CLI mangler for Portage package.* configuration files"""
2 | 
3 | __version__ = "0.99.8"
4 | 


--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
 1 | [tox]
 2 | envlist = qa,py39,py310,py311,pypy3
 3 | isolated_build = True
 4 | 
 5 | [testenv]
 6 | deps =
 7 |     mypy
 8 | extras =
 9 |     test
10 | commands =
11 |     pytest -vv {posargs:test}
12 |     mypy {posargs:flaggie test}
13 | 
14 | [testenv:qa]
15 | skip_install = true
16 | deps =
17 |     pycodestyle
18 |     pyflakes
19 | commands =
20 |     pyflakes {posargs:flaggie test}
21 |     pycodestyle {posargs:flaggie test}
22 | 
23 | [testenv:upload]
24 | skip_install = true
25 | deps =
26 |     build
27 |     twine
28 | commands =
29 |     python -m build -s -w
30 |     twine upload dist/*
31 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yaml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | on: [push, pull_request]
 3 | jobs:
 4 |   ci:
 5 |     strategy:
 6 |       matrix:
 7 |         python-version: ["3.9", "3.10", "3.11", "3.12-dev", "pypy-3.9"]
 8 |       fail-fast: false
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - name: Checkout
12 |         uses: actions/checkout@v2
13 |       - name: Set up Python
14 |         uses: actions/setup-python@v3
15 |         with:
16 |           python-version: ${{ matrix.python-version }}
17 |       - name: Install tox
18 |         run: pip install tox
19 |       - name: Test using tox
20 |         run: tox -e py
21 |   qa:
22 |     runs-on: ubuntu-latest
23 |     steps:
24 |       - name: Checkout
25 |         uses: actions/checkout@v2
26 |       - name: Set up Python
27 |         uses: actions/setup-python@v3
28 |         with:
29 |           python-version: "3.11"
30 |       - name: Install tox
31 |         run: pip install tox
32 |       - name: Test using tox
33 |         run: tox -e qa
34 | 


--------------------------------------------------------------------------------
/COPYING:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2022 Michał Górny
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
17 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
18 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
19 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
20 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [build-system]
 2 | requires = ["flit_core >=3.2,<4"]
 3 | build-backend = "flit_core.buildapi"
 4 | 
 5 | [project]
 6 | name = "flaggie"
 7 | authors = [{name = "Michał Górny", email = "mgorny@gentoo.org"}]
 8 | license = {file = "COPYING"}
 9 | classifiers = ["License :: OSI Approved :: MIT License"]
10 | dynamic = ["version", "description"]
11 | requires-python = ">=3.9"
12 | dependencies = [
13 |     "more-itertools",
14 | ]
15 | 
16 | [project.optional-dependencies]
17 | package-manager = [
18 |     "gentoopm >= 0.5",
19 | ]
20 | pretty-log = [
21 |     "rich",
22 | ]
23 | test = [
24 |     "pytest",
25 | ]
26 | 
27 | [project.scripts]
28 | flaggie = "flaggie.__main__:entry_point"
29 | 
30 | [project.urls]
31 | Homepage = "https://github.com/projg2/flaggie/"
32 | 
33 | [tool.flit.sdist]
34 | include = [
35 |     "test",
36 |     "tox.ini",
37 | ]
38 | 
39 | [tool.mypy]
40 | disallow_untyped_defs = true
41 | no_implicit_optional = true
42 | 
43 | [[tool.mypy.overrides]]
44 | module = [
45 |     "test.*",
46 | ]
47 | # requiring explicit types for all test methods would be cumbersome
48 | disallow_untyped_defs = false
49 | check_untyped_defs = true
50 | 
51 | [[tool.mypy.overrides]]
52 | module = [
53 |     "gentoopm.*",
54 |     "rich.*",
55 | ]
56 | ignore_missing_imports = true
57 | 
58 | [tool.pytest.ini_options]
59 | addopts = "--log-level=debug"
60 | testpaths = [
61 |     "test",
62 | ]
63 | 


--------------------------------------------------------------------------------
/test/test_main.py:
--------------------------------------------------------------------------------
 1 | # (c) 2023 Michał Górny
 2 | # Released under the terms of the MIT license
 3 | 
 4 | import argparse
 5 | 
 6 | import pytest
 7 | 
 8 | from flaggie.__main__ import (split_arg_sets, split_op,
 9 |                               namespace_into_token_group,
10 |                               )
11 | from flaggie.config import TokenType
12 | 
13 | 
14 | @pytest.mark.parametrize(
15 |     "args,expected",
16 |     [(["+foo", "-bar"], [([], ["+foo", "-bar"])]),
17 |      (["dev-foo/bar", "+foo"], [(["dev-foo/bar"], ["+foo"])]),
18 |      (["dev-foo/bar", "baz", "-foo"],
19 |       [(["dev-foo/bar", "baz"], ["-foo"])]),
20 |      (["+foo", "dev-foo/*", "-foo"],
21 |       [([], ["+foo"]), (["dev-foo/*"], ["-foo"])]),
22 |      ([">=dev-foo/bar-11-r1", "+foo"], [([">=dev-foo/bar-11-r1"], ["+foo"])]),
23 |      (["<bar-11", "+foo"], [(["<bar-11"], ["+foo"])]),
24 |      (["~dev-foo/bar-21", "+foo"], [(["~dev-foo/bar-21"], ["+foo"])]),
25 |      (["=bar-14*", "+foo"], [(["=bar-14*"], ["+foo"])]),
26 |      ])
27 | def test_split_arg_sets(args, expected):
28 |     argp = argparse.ArgumentParser()
29 |     assert list(split_arg_sets(argp, args)) == expected
30 | 
31 | 
32 | @pytest.mark.parametrize(
33 |     "args",
34 |     [[""],
35 |      ["dev-foo/bar"],
36 |      ["dev-foo/*", "baz", "+flag", "pkg"],
37 |      ])
38 | def test_split_arg_sets_invalid(args):
39 |     argp = argparse.ArgumentParser()
40 |     with pytest.raises(SystemExit):
41 |         list(split_arg_sets(argp, args))
42 | 
43 | 
44 | @pytest.mark.parametrize(
45 |     "op,expected",
46 |     [("+foo", ("+", None, "foo")),
47 |      ("-use::foo", ("-", "use", "foo")),
48 |      ("%", ("%", None, None)),
49 |      ])
50 | def test_split_op(op, expected):
51 |     assert split_op(op) == expected
52 | 
53 | 
54 | @pytest.mark.parametrize(
55 |     "arg,expected",
56 |     [("use", (TokenType.USE_FLAG, None)),
57 |      ("kw", (TokenType.KEYWORD, None)),
58 |      ("PYTHON_TARGETS", (TokenType.USE_FLAG, "PYTHON_TARGETS")),
59 |      ])
60 | def test_namespace_into_token_group(arg, expected):
61 |     assert namespace_into_token_group(arg) == expected
62 | 


--------------------------------------------------------------------------------
/test/test_config.py:
--------------------------------------------------------------------------------
  1 | # (c) 2022-2023 Michał Górny
  2 | # Released under the terms of the MIT license
  3 | 
  4 | import dataclasses
  5 | import os
  6 | import stat
  7 | 
  8 | import pytest
  9 | 
 10 | from flaggie.config import (TokenType, ConfigLine, find_config_files,
 11 |                             parse_config_file, dump_config_line,
 12 |                             ConfigFile, read_config_files, save_config_files,
 13 |                             )
 14 | 
 15 | 
 16 | @pytest.mark.parametrize(
 17 |     "layout,expected",
 18 |     [([], ["package.use/99local.conf"]),
 19 |      (["package.use"], None),
 20 |      (["package.use/a.conf", "package.use/b.conf"], None),
 21 |      (["package.use/a/foo.conf", "package.use/b/foo.conf"], None),
 22 |      # even though "a+" sorts before "a/", directories take precedence
 23 |      (["package.use/a/foo.conf", "package.use/a+"], None),
 24 |      # hidden and backup files should be ignored
 25 |      (["package.use/.foo", "package.use/foo.conf", "package.use/foo.conf~"],
 26 |       ["package.use/foo.conf"]),
 27 |      # corner case: package.use yielding no valid files
 28 |      (["package.use/.foo"], ["package.use/99local.conf"]),
 29 |      ])
 30 | def test_find_config(tmp_path, layout, expected):
 31 |     confdir = tmp_path / "etc/portage"
 32 |     for f in layout:
 33 |         path = confdir / f
 34 |         path.parent.mkdir(parents=True, exist_ok=True)
 35 |         with open(path, "wb"):
 36 |             pass
 37 |     if expected is None:
 38 |         expected = layout
 39 |     assert find_config_files(tmp_path, TokenType.USE_FLAG
 40 |                              ) == [confdir / x for x in expected]
 41 | 
 42 | 
 43 | TEST_CONFIG_FILE = [
 44 |     "#initial comment\n",
 45 |     "  # comment with whitespace\n",
 46 |     "\n",
 47 |     "*/* foo bar baz # global flags\n",
 48 |     "*/* FROBNICATE_TARGETS: frob1 frob2\n",
 49 |     "  dev-foo/bar weird#flag other # actual comment # more comment\n",
 50 |     "dev-foo/baz mixed LONG: too EMPTY:\n"
 51 | ]
 52 | 
 53 | PARSED_TEST_CONFIG_FILE = [
 54 |     ConfigLine(comment="initial comment"),
 55 |     ConfigLine(comment=" comment with whitespace"),
 56 |     ConfigLine(),
 57 |     ConfigLine("*/*", ["foo", "bar", "baz"], [], " global flags"),
 58 |     ConfigLine("*/*", [], [("FROBNICATE_TARGETS", ["frob1", "frob2"])]),
 59 |     ConfigLine("dev-foo/bar", ["weird#flag", "other"], [],
 60 |                " actual comment # more comment"),
 61 |     ConfigLine("dev-foo/baz", ["mixed"], [("LONG", ["too"]), ("EMPTY", [])]),
 62 | ]
 63 | 
 64 | for raw_line, line in zip(TEST_CONFIG_FILE, PARSED_TEST_CONFIG_FILE):
 65 |     line._raw_line = raw_line
 66 | 
 67 | 
 68 | def test_parse_config_file():
 69 |     assert list(parse_config_file(TEST_CONFIG_FILE)) == PARSED_TEST_CONFIG_FILE
 70 | 
 71 | 
 72 | def test_dump_config_line():
 73 |     assert [dump_config_line(x) for x in parse_config_file(TEST_CONFIG_FILE)
 74 |             ] == [x.lstrip(" ") for x in TEST_CONFIG_FILE]
 75 | 
 76 | 
 77 | def test_read_config_files(tmp_path):
 78 |     with open(tmp_path / "config", "w") as f:
 79 |         f.write("".join(TEST_CONFIG_FILE))
 80 |     with open(tmp_path / "config2", "w") as f:
 81 |         pass
 82 | 
 83 |     assert list(read_config_files([tmp_path / "config", tmp_path / "config2"])
 84 |                 ) == [
 85 |         ConfigFile(tmp_path / "config", PARSED_TEST_CONFIG_FILE),
 86 |         ConfigFile(tmp_path / "config2", []),
 87 |     ]
 88 | 
 89 | 
 90 | def test_save_config_files_no_modification(tmp_path):
 91 |     config_files = [
 92 |         ConfigFile(tmp_path / "config", PARSED_TEST_CONFIG_FILE),
 93 |         ConfigFile(tmp_path / "config2", []),
 94 |     ]
 95 | 
 96 |     save_config_files(config_files)
 97 |     assert all(not config_file.path.exists() for config_file in config_files)
 98 | 
 99 | 
100 | def invalidate_config_lines(lines: list[ConfigLine],
101 |                             *line_nos: int,
102 |                             ) -> list[ConfigLine]:
103 |     out = list(lines)
104 |     for x in line_nos:
105 |         out[x] = dataclasses.replace(out[x])
106 |         out[x].invalidate()
107 |     return out
108 | 
109 | 
110 | @pytest.mark.parametrize("write", [False, True])
111 | def test_save_config_files(tmp_path, write):
112 |     config_files = [
113 |         ConfigFile(tmp_path / "config",
114 |                    invalidate_config_lines(PARSED_TEST_CONFIG_FILE, 1, 5),
115 |                    modified=True),
116 |         ConfigFile(tmp_path / "config2",
117 |                    [ConfigLine("dev-foo/bar", ["new"], [])],
118 |                    modified=True),
119 |         ConfigFile(tmp_path / "config3", []),
120 |     ]
121 | 
122 |     for conf in config_files:
123 |         with open(conf.path, "w") as f:
124 |             os.fchmod(f.fileno(), 0o400)
125 |             f.write("<original content>")
126 |     save_config_files(config_files,
127 |                       confirm_cb=lambda orig_file, temp_file: write)
128 | 
129 |     expected = ["<original content>" for _ in config_files]
130 |     if write:
131 |         expected[:2] = [
132 |             "".join(x.lstrip(" ") for x in TEST_CONFIG_FILE),
133 |             "dev-foo/bar new\n",
134 |         ]
135 | 
136 |     assert [conf.path.read_text() for conf in config_files] == expected
137 |     assert [stat.S_IMODE(os.stat(conf.path).st_mode) for conf in config_files
138 |             ] == [0o400 for _ in config_files]
139 | 


--------------------------------------------------------------------------------
/flaggie/config.py:
--------------------------------------------------------------------------------
  1 | # (c) 2022-2023 Michał Górny
  2 | # Released under the terms of the MIT license
  3 | 
  4 | import dataclasses
  5 | import enum
  6 | import logging
  7 | import os
  8 | import re
  9 | import shutil
 10 | import tempfile
 11 | import typing
 12 | 
 13 | from pathlib import Path
 14 | 
 15 | 
 16 | class TokenType(enum.IntEnum):
 17 |     USE_FLAG = enum.auto()
 18 |     KEYWORD = enum.auto()
 19 |     LICENSE = enum.auto()
 20 |     PROPERTY = enum.auto()
 21 |     RESTRICT = enum.auto()
 22 |     ENV_FILE = enum.auto()
 23 | 
 24 | 
 25 | @dataclasses.dataclass
 26 | class ConfigLine:
 27 |     package: typing.Optional[str] = None
 28 |     flat_flags: list[str] = dataclasses.field(default_factory=list)
 29 |     grouped_flags: list[tuple[str, list[str]]
 30 |                         ] = dataclasses.field(default_factory=list)
 31 |     comment: typing.Optional[str] = None
 32 | 
 33 |     _raw_line: typing.Optional[str] = dataclasses.field(default=None,
 34 |                                                         compare=False)
 35 | 
 36 |     def invalidate(self) -> None:
 37 |         """Mark the ConfigLine as modified"""
 38 |         self._raw_line = None
 39 | 
 40 |     @property
 41 |     def raw_line(self) -> str:
 42 |         if self._raw_line is None:
 43 |             self._raw_line = dump_config_line(self)
 44 |         return self._raw_line
 45 | 
 46 | 
 47 | @dataclasses.dataclass
 48 | class ConfigFile:
 49 |     path: Path
 50 |     parsed_lines: list[ConfigLine]
 51 |     modified: bool = False
 52 | 
 53 | 
 54 | CONFIG_FILENAMES = {
 55 |     TokenType.USE_FLAG: "package.use",
 56 |     TokenType.KEYWORD: "package.accept_keywords",
 57 |     TokenType.LICENSE: "package.license",
 58 |     TokenType.PROPERTY: "package.properties",
 59 |     TokenType.RESTRICT: "package.accept_restrict",
 60 |     TokenType.ENV_FILE: "package.env",
 61 | }
 62 | 
 63 | COMMENT_RE = re.compile(r"(?<!\S)#(.*)$")
 64 | 
 65 | 
 66 | def find_config_files(config_root: Path, token_type: TokenType) -> list[Path]:
 67 |     """
 68 |     Find all configuration files of given type
 69 | 
 70 |     Find all configuration files of type `token_type` inside root
 71 |     `config_root` (usually "/").  Returns a list of paths sorted in the same
 72 |     order as they are read by Portage.
 73 |     """
 74 | 
 75 |     path = config_root / "etc/portage" / CONFIG_FILENAMES[token_type]
 76 | 
 77 |     # if it's an existing directory, find the last visible file
 78 |     # in the directory (provided there is any)
 79 |     if path.is_dir():
 80 |         def _is_visible(fn: str) -> bool:
 81 |             return not fn.startswith(".") and not fn.endswith("~")
 82 | 
 83 |         # yes, Portage is insane
 84 |         def _get_all_paths_recursively(topdir: Path
 85 |                                        ) -> typing.Generator[Path, None, None]:
 86 |             for curpath, dirnames, filenames in os.walk(path):
 87 |                 dirnames = list(filter(_is_visible, dirnames))
 88 |                 for f in filter(_is_visible, filenames):
 89 |                     yield Path(curpath) / f
 90 | 
 91 |         all_files = sorted(_get_all_paths_recursively(path))
 92 |         if all_files:
 93 |             return all_files
 94 |         path /= "99local.conf"
 95 |         path.touch()
 96 |         return [path]
 97 | 
 98 |     # if it does not exist yet, create a new directory and put a `local.conf`
 99 |     # in there
100 |     if not path.exists():
101 |         path.mkdir(parents=True)
102 |         path /= "99local.conf"
103 |         path.touch()
104 |         return [path]
105 | 
106 |     # otherwise (presumably it's a file), use the path directly
107 |     return [path]
108 | 
109 | 
110 | def parse_config_file(lines: list[str]
111 |                       ) -> typing.Generator[ConfigLine, None, None]:
112 |     """
113 |     Parse config file data
114 | 
115 |     Parse the config file data supplied as list of lines into a list
116 |     of corresponding ConfigLine objects.
117 |     """
118 | 
119 |     for raw_line in lines:
120 |         line = raw_line.rstrip()
121 |         comment_m = COMMENT_RE.search(line)
122 |         if comment_m is not None:
123 |             line = line[:comment_m.start()]
124 | 
125 |         split = line.split()
126 |         group: tuple[str, list[str]] = ("", [])
127 |         groups = [group]
128 |         for flag in split[1:]:
129 |             if flag.endswith(":"):
130 |                 group = (flag[:-1], [])
131 |                 groups.append(group)
132 |                 continue
133 |             group[1].append(flag)
134 | 
135 |         assert groups[0][0] == ""
136 |         yield ConfigLine(
137 |             package=split[0] if split else None,
138 |             flat_flags=groups[0][1],
139 |             grouped_flags=groups[1:],
140 |             comment=comment_m.group(1) if comment_m is not None else None,
141 |             _raw_line=raw_line)
142 | 
143 | 
144 | def dump_config_line(line: ConfigLine) -> str:
145 |     """
146 |     Convert ConfigLine back into str
147 |     """
148 | 
149 |     def inner() -> typing.Generator[str, None, None]:
150 |         if line.package is not None:
151 |             yield line.package
152 |         yield from line.flat_flags
153 |         for group, flags in line.grouped_flags:
154 |             yield f"{group}:"
155 |             yield from flags
156 |         if line.comment is not None:
157 |             yield f"#{line.comment}"
158 | 
159 |     return " ".join(inner()) + "\n"
160 | 
161 | 
162 | def read_config_files(paths: typing.Iterable[Path]
163 |                       ) -> typing.Generator[ConfigFile, None, None]:
164 |     """
165 |     Read and parse data from config files passed in.
166 |     """
167 | 
168 |     for path in paths:
169 |         logging.debug(f"Loading config file {path}")
170 |         with open(path, "r") as f:
171 |             yield ConfigFile(path, list(parse_config_file(f.readlines())))
172 | 
173 | 
174 | def save_config_files(config_files: typing.Iterable[ConfigFile],
175 |                       confirm_cb: typing.Callable[[Path, Path], bool] =
176 |                       lambda orig_file, temp_file: True,
177 |                       ) -> None:
178 |     """
179 |     Update raw data in modified config files and write them back
180 | 
181 |     confirm_cb specifies a callback function that is called with
182 |     the path to the original config file and the path to the temporary
183 |     file with the new config.  If it returns True, the config file
184 |     is replaced.  Otherwise, the new config is discarded.
185 |     """
186 | 
187 |     for config_file in config_files:
188 |         if not config_file.modified:
189 |             continue
190 | 
191 |         temp_path = None
192 |         try:
193 |             with tempfile.NamedTemporaryFile(mode="w",
194 |                                              dir=config_file.path.parent,
195 |                                              delete=False) as f:
196 |                 temp_path = Path(f.name)
197 |                 logging.debug(
198 |                     f"Writing config file {config_file.path} as {temp_path}")
199 | 
200 |                 # typeshed is missing fd support in shutil.copymode()
201 |                 # https://github.com/python/typeshed/issues/9288
202 |                 shutil.copymode(config_file.path, f.fileno())  # type: ignore
203 |                 f.write("".join(line.raw_line
204 |                                 for line in config_file.parsed_lines))
205 | 
206 |             if confirm_cb(config_file.path, temp_path):
207 |                 logging.debug(f"Replacing {config_file.path}")
208 |                 temp_path.rename(config_file.path)
209 |             else:
210 |                 temp_path.unlink()
211 |         except Exception:
212 |             if temp_path is not None:
213 |                 temp_path.unlink()
214 |             raise
215 | 


--------------------------------------------------------------------------------
/test/test_pm.py:
--------------------------------------------------------------------------------
  1 | # (c) 2023 Michał Górny
  2 | # Released under the terms of the MIT license
  3 | 
  4 | import typing
  5 | 
  6 | from pathlib import Path
  7 | 
  8 | from flaggie.config import TokenType
  9 | from flaggie.pm import (match_package, get_valid_values, split_use_expand,
 10 |                         MatchError,
 11 |                         )
 12 | 
 13 | import pytest
 14 | 
 15 | 
 16 | VALID_SPECS = [
 17 |     "app-foo/bar",
 18 |     ">=app-foo/bar-1-r1",
 19 |     "=app-foo/bar-29*",
 20 |     "*/*",
 21 |     "app-foo/*",
 22 | ]
 23 | 
 24 | SHORT_SPECS = [
 25 |     "bar",
 26 |     ">=bar-11",
 27 | ]
 28 | 
 29 | 
 30 | class UseExpand(typing.NamedTuple):
 31 |     name: str
 32 |     prefixed: bool
 33 |     visible: bool
 34 |     values: dict[str, typing.Any]
 35 | 
 36 | 
 37 | class ArchDesc(typing.NamedTuple):
 38 |     name: str
 39 |     stability: typing.Optional[str]
 40 | 
 41 | 
 42 | class MockedPM:
 43 |     def __init__(self, config_root: typing.Optional[Path] = None):
 44 |         self.config_root = config_root
 45 | 
 46 |     class Atom:
 47 |         class _key(typing.NamedTuple):
 48 |             category: typing.Optional[str]
 49 |             package: str
 50 | 
 51 |             def __str__(self):
 52 |                 return f"{self.category}/{self.package}"
 53 | 
 54 |         def __init__(self, atom: str) -> None:
 55 |             assert "/*" not in atom
 56 |             self._atom = atom
 57 | 
 58 |         def __str__(self) -> str:
 59 |             return self._atom
 60 | 
 61 |         @property
 62 |         def key(self):
 63 |             key = self._atom.lstrip("<>=~").rstrip("-0123456789")
 64 |             if "/" in key:
 65 |                 return self._key(*key.split("/", 1))
 66 |             return self._key(None, key)
 67 | 
 68 |         @property
 69 |         def keywords(self):
 70 |             if self._atom == "=app-foo/bar-1":
 71 |                 return frozenset(["-*", "amd64"])
 72 |             elif self._atom == "=app-foo/bar-2":
 73 |                 return frozenset(["~amd64", "~riscv"])
 74 |             return frozenset([])
 75 | 
 76 |         @property
 77 |         def license(self):
 78 |             return [["Apache-2.0", "MIT"], "BSD"]
 79 | 
 80 |         @property
 81 |         def properties(self):
 82 |             return ["live"]
 83 | 
 84 |         @property
 85 |         def restrict(self):
 86 |             return ["fetch", "mirror", ["test"]]
 87 | 
 88 |         @property
 89 |         def use(self):
 90 |             return frozenset(["foo", "-bar", "+targets_frobnicate"])
 91 | 
 92 |     class stack:
 93 |         @staticmethod
 94 |         def filter(atom: typing.Union["MockedPM.Atom", str],
 95 |                    ) -> list["MockedPM.Atom"]:
 96 |             atom = str(atom)
 97 |             if atom.startswith("="):
 98 |                 return [MockedPM.Atom(atom)]
 99 |             if atom == "enoent":
100 |                 return []
101 |             if atom == "multiple":
102 |                 return [
103 |                     MockedPM.Atom("app-foo/multi"),
104 |                     MockedPM.Atom("app-bar/multi"),
105 |                 ]
106 |             atom = atom.lstrip("<>=").rstrip("-0123456789")
107 |             if "/" not in atom:
108 |                 atom = f"app-foo/{atom}"
109 |             return [
110 |                 MockedPM.Atom(f"={atom}-1"),
111 |                 MockedPM.Atom(f"={atom}-2"),
112 |             ]
113 | 
114 |         arches = {
115 |             "amd64": ArchDesc(name="amd64", stability="stable"),
116 |             "loong": ArchDesc(name="loong", stability="testing"),
117 |             "riscv": ArchDesc(name="riscv", stability="transitional"),
118 |             "riscv-linux": ArchDesc(name="riscv-linux", stability=None),
119 |         }
120 |         global_use = {"baz": None, "fjord": None}
121 |         license_groups = {
122 |             "FSF-APPROVED": None,
123 |             "OSI-APPROVED": None,
124 |         }
125 |         licenses = {
126 |             "Apache-2.0": None,
127 |             "BSD": None,
128 |         }
129 |         use_expand = {
130 |             "GLOBAL": UseExpand(name="GLOBAL",
131 |                                 prefixed=True,
132 |                                 visible=True,
133 |                                 values={"val1": None,
134 |                                         "val2": None,
135 |                                         "val3": None,
136 |                                         }),
137 |             "UNPREFIXED": UseExpand(name="UNPREFIXED",
138 |                                     prefixed=False,
139 |                                     visible=True,
140 |                                     values={"val1": None,
141 |                                             "val2": None,
142 |                                             }),
143 |         }
144 | 
145 | 
146 | @pytest.mark.parametrize("package", VALID_SPECS)
147 | @pytest.mark.parametrize("pm", [None, MockedPM()])
148 | def test_match_package(pm, package):
149 |     assert match_package(pm, package) == package
150 | 
151 | 
152 | @pytest.mark.parametrize("package", SHORT_SPECS)
153 | def test_match_package_expand(package):
154 |     assert (match_package(MockedPM(), package) ==
155 |             package.replace("bar", "app-foo/bar"))
156 | 
157 | 
158 | @pytest.mark.parametrize("pkg", ["enoent", "multiple"])
159 | def test_match_package_expand_raise(pkg):
160 |     with pytest.raises(MatchError):
161 |         match_package(MockedPM(), pkg)
162 | 
163 | 
164 | @pytest.mark.parametrize("package", SHORT_SPECS + ["*"])
165 | def test_match_package_no_pm_no_category(package):
166 |     with pytest.raises(ValueError):
167 |         match_package(None, package)
168 | 
169 | 
170 | @pytest.mark.parametrize(
171 |     "package,token_type,group,expected",
172 |     [("app-foo/bar", TokenType.USE_FLAG, None,
173 |       ["*", "targets_frobnicate", "foo", "bar"]),
174 |      ("app-foo/bar", TokenType.USE_FLAG, "TARGETS",
175 |       ["*", "frobnicate"]),
176 |      ("app-foo/bar", TokenType.KEYWORD, None,
177 |       ["*", "~*", "**", "~amd64", "amd64", "~riscv"]),
178 |      ("=app-foo/bar-1", TokenType.KEYWORD, None,
179 |       ["*", "~*", "**", "~amd64", "amd64"]),
180 |      ("=app-foo/bar-2", TokenType.KEYWORD, None,
181 |       ["~*", "**", "~amd64", "~riscv"]),
182 |      ("=app-foo/live-1", TokenType.KEYWORD, None,
183 |       ["**"]),
184 |      ("=app-foo/live-1", TokenType.LICENSE, None,
185 |       ["*", "@FSF-APPROVED", "@OSI-APPROVED", "Apache-2.0", "BSD", "MIT"]),
186 |      ("=app-foo/live-1", TokenType.PROPERTY, None,
187 |       ["*", "live"]),
188 |      ("=app-foo/live-1", TokenType.RESTRICT, None,
189 |       ["*", "fetch", "mirror", "test"]),
190 |      ("*/*", TokenType.USE_FLAG, None,
191 |       ["*", "baz", "fjord"]),
192 |      ("*/*", TokenType.USE_FLAG, "GLOBAL",
193 |       ["*", "val1", "val2", "val3"]),
194 |      ("*/*", TokenType.USE_FLAG, "INVALID", []),
195 |      ("*/*", TokenType.USE_FLAG, "UNPREFIXED", []),
196 |      ("*/*", TokenType.KEYWORD, None,
197 |       ["*", "~*", "**", "~amd64", "amd64", "~loong", "riscv", "~riscv",
198 |        "riscv-linux", "~riscv-linux"]),
199 |      ("*/*", TokenType.LICENSE, None,
200 |       ["*", "@FSF-APPROVED", "@OSI-APPROVED", "Apache-2.0", "BSD"]),
201 |      ])
202 | def test_get_valid_values_pkg(package, token_type, group, expected):
203 |     assert (get_valid_values(MockedPM(), package, token_type, group) ==
204 |             frozenset(expected))
205 | 
206 | 
207 | def test_get_valid_values_env(tmp_path):
208 |     env_dir = tmp_path / "etc/portage/env"
209 |     env_dir.mkdir(parents=True)
210 |     expected = frozenset(["foo", "bar", "baz"])
211 |     for filename in expected:
212 |         (env_dir / filename).touch()
213 |     assert get_valid_values(MockedPM(tmp_path), "dev-foo/bar",
214 |                             TokenType.ENV_FILE, None) == expected
215 | 
216 | 
217 | def test_get_valid_values_env_not_exist(tmp_path):
218 |     assert get_valid_values(MockedPM(tmp_path), "dev-foo/bar",
219 |                             TokenType.ENV_FILE, None) == set()
220 | 
221 | 
222 | @pytest.mark.parametrize(
223 |     "flag,expected",
224 |     [("foo", (None, "foo")),
225 |      ("global_foo", ("GLOBAL", "foo")),
226 |      ("unprefixed_foo", (None, "unprefixed_foo")),
227 |      ])
228 | def test_split_use_expand(flag, expected):
229 |     assert split_use_expand(MockedPM(), flag) == expected
230 | 


--------------------------------------------------------------------------------
/flaggie/pm.py:
--------------------------------------------------------------------------------
  1 | # (c) 2023 Michał Górny
  2 | # Released under the terms of the MIT license
  3 | 
  4 | import functools
  5 | import logging
  6 | import typing
  7 | 
  8 | from pathlib import Path
  9 | 
 10 | import more_itertools
 11 | 
 12 | from flaggie.config import TokenType
 13 | from flaggie.mangle import is_wildcard_package
 14 | 
 15 | 
 16 | if typing.TYPE_CHECKING:
 17 |     import gentoopm
 18 | 
 19 | 
 20 | class MatchError(RuntimeError):
 21 |     pass
 22 | 
 23 | 
 24 | @functools.cache
 25 | def _filter_packages(pm: "gentoopm.basepm.PMBase",
 26 |                      query: str,
 27 |                      ) -> list["gentoopm.basepm.pkg.PMPackage"]:
 28 |     return pm.stack.filter(query)
 29 | 
 30 | 
 31 | def match_package(pm: typing.Optional["gentoopm.basepm.PMBase"],
 32 |                   package_spec: str,
 33 |                   ) -> str:
 34 |     """
 35 |     Match package spec against the repos
 36 | 
 37 |     Match the package specification against the repositories provided
 38 |     by the package manager instance.  Returns the (possibly expanded)
 39 |     package specification or raises an exception.
 40 |     """
 41 | 
 42 |     if pm is None or is_wildcard_package(package_spec):
 43 |         # if PM is not available or we're dealing with wildcards,
 44 |         # just perform basic validation
 45 |         # TODO: better validation?
 46 |         if package_spec.count("/") != 1:
 47 |             raise ValueError("Not a valid category/package spec")
 48 |         return package_spec
 49 | 
 50 |     parsed = pm.Atom(package_spec)
 51 |     matched = frozenset(str(pkg.key)
 52 |                         for pkg in _filter_packages(pm, package_spec))
 53 |     if not matched:
 54 |         raise MatchError(f"{package_spec!r} matched no packages")
 55 |     if len(matched) > 1:
 56 |         raise MatchError(
 57 |             f"{package_spec!r} is ambigous, matched {', '.join(matched)}")
 58 | 
 59 |     if parsed.key.category is None:
 60 |         # if user did not specify the category, copy it from the match
 61 |         # TODO: have gentoopm provide a better API for modifying atoms?
 62 |         return package_spec.replace(str(parsed.key.package), str(*matched))
 63 | 
 64 |     return package_spec
 65 | 
 66 | 
 67 | @functools.cache
 68 | def get_valid_values(pm: typing.Optional["gentoopm.basepm.PMBase"],
 69 |                      package_spec: str,
 70 |                      token_type: TokenType,
 71 |                      group: typing.Optional[str],
 72 |                      ) -> typing.Optional[set[str]]:
 73 |     """Get a list of valid values for (package, token type, group)"""
 74 | 
 75 |     if pm is None:
 76 |         return None
 77 | 
 78 |     # env files are global by design
 79 |     if token_type == TokenType.ENV_FILE:
 80 |         env_dir = Path(pm.config_root or "/") / "etc/portage/env"
 81 |         if not env_dir.is_dir():
 82 |             logging.debug(f"{env_dir} is not a directory, no valid "
 83 |                           f"{token_type.name} values")
 84 |             return set()
 85 |         values = set(path.name for path in env_dir.iterdir() if path.is_file())
 86 |         logging.debug(f"Valid values for {token_type.name}: {values}")
 87 |         return values
 88 | 
 89 |     # wildcard packages not supported
 90 |     if package_spec != "*/*" and is_wildcard_package(package_spec):
 91 |         return None
 92 | 
 93 |     group_match = ""
 94 |     group_len = 0
 95 |     if group is not None:
 96 |         group_match = group.lower() + "_"
 97 |         group_len = len(group_match)
 98 | 
 99 |     values = set()
100 |     values.add("**" if token_type == TokenType.KEYWORD else "*")
101 |     if token_type == TokenType.LICENSE:
102 |         values.update(f"@{name}" for name in pm.stack.license_groups)
103 | 
104 |     if package_spec == "*/*":
105 |         if token_type == TokenType.USE_FLAG:
106 |             if group is not None:
107 |                 use_expand = pm.stack.use_expand.get(group)
108 |                 if use_expand is None:
109 |                     logging.debug(
110 |                         f"{token_type.name} group: {group} is not valid")
111 |                     return set()
112 |                 if not use_expand.prefixed:
113 |                     logging.debug(
114 |                         f"{token_type.name} group: {group} is not prefixed")
115 |                     return set()
116 |                 values.update(use_expand.values)
117 |             else:
118 |                 # NB: we deliberately ignore use_expand, as flaggie
119 |                 # is expected to have detected it and set the group
120 |                 values.update(pm.stack.global_use)
121 |         elif token_type == TokenType.KEYWORD:
122 |             values.update(["*", "~*"])
123 |             arches = pm.stack.arches.values()
124 |             values.update(f"~{arch.name}" for arch in arches)
125 |             values.update(arch.name for arch in arches
126 |                           if arch.stability != "testing")
127 |         elif token_type == TokenType.LICENSE:
128 |             values.update(pm.stack.licenses)
129 |         elif token_type == TokenType.PROPERTY:
130 |             # The PMs do not keep easily accessible lists of supported
131 |             # PROPERTIES/RESTRICT values.  We could use *-allowed
132 |             # from layout.conf but that would limit the available set
133 |             # to these explicitly supported in ::gentoo.  Hardcoding
134 |             # the complete set is also easier.
135 | 
136 |             # PMS-defined values
137 |             values.update(["interactive", "live", "test_network"])
138 |         elif token_type == TokenType.RESTRICT:
139 |             # PMS-defined values
140 |             values.update(["fetch", "mirror", "strip", "test", "userpriv"])
141 |             # Additional Portage-defined values
142 |             values.update(["binchecks", "bindist", "installsources",
143 |                            "network-sandbox", "preserve-libs", "primaryuri",
144 |                            "splitdebug",
145 |                            ])
146 |         else:
147 |             assert False, f"Unhandled token type {token_type.name}"
148 |     else:
149 |         for pkg in _filter_packages(pm, package_spec):
150 |             if token_type == TokenType.USE_FLAG:
151 |                 for flag in pkg.use:
152 |                     flag = flag.lstrip("+-")
153 |                     if flag.lower().startswith(group_match):
154 |                         values.add(flag[group_len:])
155 |             elif token_type == TokenType.KEYWORD:
156 |                 for keyword in pkg.keywords:
157 |                     if keyword.startswith("-"):
158 |                         continue
159 |                     values.add(keyword)
160 |                     values.add("~*")
161 |                     if not keyword.startswith("~"):
162 |                         values.add("*")
163 |                         # allow ~arch even if the package is stable already
164 |                         # https://github.com/projg2/flaggie/issues/42
165 |                         values.add(f"~{keyword}")
166 |             elif token_type == TokenType.LICENSE:
167 |                 values.update(more_itertools.collapse(pkg.license))
168 |             elif token_type == TokenType.PROPERTY:
169 |                 values.update(more_itertools.collapse(pkg.properties))
170 |             elif token_type == TokenType.RESTRICT:
171 |                 values.update(more_itertools.collapse(pkg.restrict))
172 |             else:
173 |                 assert False, f"Unhandled token type {token_type.name}"
174 | 
175 |     logging.debug(
176 |         f"Valid values for {package_spec} {token_type.name} group: {group}: "
177 |         f"{values}")
178 |     return values
179 | 
180 | 
181 | @functools.cache
182 | def split_use_expand(pm: typing.Optional["gentoopm.basepm.PMBase"],
183 |                      flag: str,
184 |                      ) -> tuple[typing.Optional[str], str]:
185 |     """Split given flag into (group, name) using USE_EXPAND"""
186 | 
187 |     if pm is not None:
188 |         flag_uc = flag.upper()
189 |         # start with longest first, in case they overlap
190 |         for group in sorted((group.name
191 |                              for group in pm.stack.use_expand.values()
192 |                              if group.prefixed),
193 |                             key=lambda x: -len(x)):
194 |             if flag_uc.startswith(f"{group}_"):
195 |                 return (group, flag[len(group)+1:])
196 | 
197 |     return (None, flag)
198 | 


--------------------------------------------------------------------------------
/flaggie/__main__.py:
--------------------------------------------------------------------------------
  1 | # (c) 2022-2023 Michał Górny
  2 | # Released under the terms of the MIT license
  3 | 
  4 | import argparse
  5 | import functools
  6 | import logging
  7 | import os.path
  8 | import shlex
  9 | import shutil
 10 | import subprocess
 11 | import sys
 12 | import textwrap
 13 | import typing
 14 | 
 15 | from functools import partial
 16 | from pathlib import Path
 17 | 
 18 | from flaggie import __version__
 19 | from flaggie.config import (TokenType, find_config_files, read_config_files,
 20 |                             save_config_files, ConfigFile,
 21 |                             )
 22 | from flaggie.mangle import mangle_flag, remove_flag
 23 | from flaggie.pm import (match_package, get_valid_values, split_use_expand,
 24 |                         MatchError,
 25 |                         )
 26 | 
 27 | if typing.TYPE_CHECKING:
 28 |     import gentoopm
 29 | 
 30 | 
 31 | class Operation(typing.NamedTuple):
 32 |     function: typing.Callable[[list[ConfigFile],  # config_files
 33 |                                str,  # package
 34 |                                typing.Optional[str],  # prefix
 35 |                                typing.Optional[str],  # flag
 36 |                                ], None]
 37 |     flag_required: bool
 38 |     verify_flag: bool
 39 |     match_multiple_ns: bool
 40 | 
 41 | 
 42 | OPERATOR_MAP = {
 43 |     "+": Operation(function=functools.partial(mangle_flag, new_state=True),
 44 |                    flag_required=True,
 45 |                    verify_flag=True,
 46 |                    match_multiple_ns=False,
 47 |                    ),
 48 |     "-": Operation(function=functools.partial(mangle_flag, new_state=False),
 49 |                    flag_required=True,
 50 |                    verify_flag=True,
 51 |                    match_multiple_ns=False,
 52 |                    ),
 53 |     "%": Operation(function=remove_flag,
 54 |                    flag_required=False,
 55 |                    verify_flag=False,
 56 |                    match_multiple_ns=True,
 57 |                    ),
 58 | }
 59 | 
 60 | 
 61 | def split_arg_sets(argp: argparse.ArgumentParser, args: list[str]
 62 |                    ) -> typing.Generator[tuple[list[str], list[str]],
 63 |                                          None, None]:
 64 |     """Split arguments into tuples of (packages, actions)"""
 65 | 
 66 |     packages: list[str] = []
 67 |     ops: list[str] = []
 68 |     for arg in args:
 69 |         if not arg:
 70 |             argp.error("Empty string in requests")
 71 |         if arg[0] in OPERATOR_MAP:
 72 |             ops.append(arg)
 73 |             continue
 74 |         if ops:
 75 |             yield (packages, ops)
 76 |             packages = []
 77 |             ops = []
 78 |         packages.append(arg)
 79 |     if not ops:
 80 |         argp.error(
 81 |             f"Packages ({' '.join(packages)}) with no operations specified "
 82 |             "in requests")
 83 |     yield (packages, ops)
 84 | 
 85 | 
 86 | def split_op(op: str,
 87 |              ) -> tuple[str, typing.Optional[str], typing.Optional[str]]:
 88 |     """Split operation argument into (operation, namespace, flag)"""
 89 | 
 90 |     operator = op[0]
 91 |     split = op[1:].split("::", 1)
 92 |     ns = split[0] if len(split) == 2 else None
 93 |     flag = split[-1] or None
 94 |     return (operator, ns, flag)
 95 | 
 96 | 
 97 | NAMESPACE_MAP = {
 98 |     "use": TokenType.USE_FLAG,
 99 |     "kw": TokenType.KEYWORD,
100 |     "lic": TokenType.LICENSE,
101 |     "prop": TokenType.PROPERTY,
102 |     "restrict": TokenType.RESTRICT,
103 |     "env": TokenType.ENV_FILE,
104 | }
105 | 
106 | 
107 | def namespace_into_token_group(ns: str) -> tuple[TokenType,
108 |                                                  typing.Optional[str]]:
109 |     """Map namespace into a tuple of (token type, group name)"""
110 | 
111 |     token_type = NAMESPACE_MAP.get(ns)
112 |     if token_type is not None:
113 |         return (token_type, None)
114 |     return (TokenType.USE_FLAG, ns)
115 | 
116 | 
117 | REQUEST_HELP = """
118 | Every request consists of zero or more packages, followed by one or more \
119 | flag changes, i.e.:
120 | 
121 |   request = [package ...] op [op ...]
122 | 
123 | Packages can be specified in any form suitable for package.* files. \
124 | If category is omitted, a package lookup is attempted. If no packages \
125 | are specified, "*/*" is assumed.
126 | 
127 | The operations supported are:
128 | 
129 |   +[ns::]flag         Enable specified flag
130 |   -[ns::]flag         Disable specified flag
131 |   %[ns::][flag]       Removed specified flag (or all flags)
132 | 
133 | Every flag can be prefixed using namespace, followed by "::".  The namespace \
134 | can either be a USE_EXPAND name or one of the special values:
135 | 
136 |   auto::              (the default) recognize type
137 |   env::               package.env entries
138 |   kw::                package.accept_keywords entries
139 |   lic::               package.license entries
140 |   prop::              package.properties entries
141 |   restrict::          package.accept_restrict entries
142 |   use::               package.use entries
143 | """
144 | 
145 | 
146 | def guess_token_type(argp: argparse.ArgumentParser,
147 |                      pm: typing.Optional["gentoopm.BasePM"],
148 |                      op: str,
149 |                      flag: str,
150 |                      packages: list[str],
151 |                      ) -> str:
152 |     if pm is None:
153 |         argp.error(
154 |             f"{op}: Flag type guessing requires package manager, "
155 |             f"pass e.g. use::{flag} to specify type")
156 | 
157 |     def get_matching_types() -> typing.Generator[tuple[str, TokenType],
158 |                                                  None, None]:
159 |         for package in packages:
160 |             for ns, token_type in NAMESPACE_MAP.items():
161 |                 values = get_valid_values(pm, package, token_type, None)
162 |                 if values is None:
163 |                     argp.error(f"{op}: Flag type guessing not supported "
164 |                                f"for {package}")
165 |                 if flag in values:
166 |                     yield (ns, token_type)
167 | 
168 |     matched_types = set(get_matching_types())
169 |     if not matched_types:
170 |         argp.error(f"{op}: Argument not recognized as any type, pass "
171 |                    f"e.g. use::{flag} to force one (for packages: "
172 |                    f"{packages})")
173 |     elif len(matched_types) > 1:
174 |         names = sorted(x[0] for x in matched_types)
175 |         argp.error(f"{op}: Argument matches multiple token types: "
176 |                    f"{', '.join(names)}; pass e.g. {names[0]}::{flag} to "
177 |                    f"disambiguate (for packages: {packages})")
178 |     return next(iter(matched_types))[0]
179 | 
180 | 
181 | def main(prog_name: str, *argv: str) -> int:
182 |     # same as argparse default, enforce for consistency
183 |     help_width = shutil.get_terminal_size().columns - 2
184 |     if help_width > 10:
185 |         epilog = "\n".join(textwrap.fill(x,
186 |                                          width=help_width,
187 |                                          drop_whitespace=False,
188 |                                          replace_whitespace=False)
189 |                            for x in REQUEST_HELP.splitlines())
190 |     else:
191 |         epilog = REQUEST_HELP
192 | 
193 |     if shutil.which("git"):
194 |         diff_default = "git --no-pager diff --no-index --word-diff --"
195 |     else:
196 |         diff_default = "diff -d -u --"
197 | 
198 |     argp = argparse.ArgumentParser(
199 |         add_help=False,
200 |         prog=os.path.basename(prog_name),
201 |         usage="%(prog)s [options] request ...",
202 |         epilog=epilog,
203 |         formatter_class=partial(argparse.RawDescriptionHelpFormatter,
204 |                                 width=help_width),
205 |         )
206 |     argp.add_argument("--config-root",
207 |                       type=Path,
208 |                       default=Path("/"),
209 |                       help="Root directory relative to which configuration "
210 |                            "files will be processed (default: /)")
211 |     argp.add_argument("--debug",
212 |                       action="store_true",
213 |                       help="Enable debug output")
214 |     argp.add_argument("--diff",
215 |                       default=diff_default,
216 |                       help="Program used to diff configs "
217 |                            f"(default: {diff_default})")
218 |     argp.add_argument("--force",
219 |                       action="store_true",
220 |                       help="Force performing the action even if arguments "
221 |                            "are invalid")
222 |     argp.add_argument("--help",
223 |                       action="help",
224 |                       help="Print help text and exit")
225 |     argp.add_argument("--no-diff",
226 |                       action="store_const",
227 |                       const=None,
228 |                       dest="diff",
229 |                       help="Do not diff configs")
230 |     argp.add_argument("--no-package-manager",
231 |                       action="store_true",
232 |                       help="Disable package manager interaction and features "
233 |                            "requiring it (category and argument type "
234 |                            "guessing, validation)")
235 |     argp.add_argument("--pretend",
236 |                       action="store_true",
237 |                       help="Do not write any changes to the original files")
238 |     argp.add_argument("--version",
239 |                       action="version",
240 |                       help="Print program version and exit",
241 |                       version=f"flaggie {__version__}")
242 |     args, request = argp.parse_known_args(argv)
243 | 
244 |     if args.debug:
245 |         logging.getLogger().setLevel(logging.DEBUG)
246 |     if not request:
247 |         argp.error("No request specified")
248 | 
249 |     pm = None
250 |     if not args.no_package_manager:
251 |         try:
252 |             import gentoopm
253 |             pm = gentoopm.get_package_manager()
254 |         except Exception:
255 |             logging.warning(
256 |                 "Package manager API init failed. You can disable package "
257 |                 "manager integration using --no-package-manager, at the cost "
258 |                 "of losing category and argument type guessing and validation")
259 |             raise
260 | 
261 |     portage_dir = args.config_root / "etc/portage"
262 |     if not portage_dir.is_dir():
263 |         argp.error(
264 |             f"{portage_dir} does not exist, did you specify correct "
265 |             "--config-root?")
266 | 
267 |     all_configs = {
268 |         k: list(read_config_files(find_config_files(args.config_root, k)))
269 |         for k in TokenType}
270 | 
271 |     for packages, ops in split_arg_sets(argp, request):
272 |         if not packages:
273 |             packages.append("*/*")
274 |         logging.debug(f"Request: packages = {packages}, ops = {ops}")
275 | 
276 |         def expand_package(pkg: str) -> str:
277 |             try:
278 |                 return match_package(pm, pkg)
279 |             except MatchError as err:
280 |                 if not args.force:
281 |                     argp.error(str(err))
282 |                 else:
283 |                     logging.warning(str(err))
284 |                 return pkg
285 | 
286 |         packages = list(map(expand_package, packages))
287 | 
288 |         for op in ops:
289 |             operator, arg_ns, flag = split_op(op)
290 |             logging.debug(f"Operation: {operator}, ns: {arg_ns}, flag: {flag}")
291 | 
292 |             try:
293 |                 operation = OPERATOR_MAP[operator]
294 |             except KeyError:
295 |                 argp.error(f"{op}: incorrect operation")
296 | 
297 |             if operation.flag_required and not flag:
298 |                 argp.error(f"{op}: flag name required")
299 | 
300 |             if arg_ns is None or arg_ns == "auto":
301 |                 if operation.match_multiple_ns:
302 |                     namespaces = list(NAMESPACE_MAP)
303 |                 else:
304 |                     assert flag is not None
305 |                     namespaces = [
306 |                         guess_token_type(argp, pm, op, flag, packages)
307 |                     ]
308 |             else:
309 |                 namespaces = [arg_ns]
310 | 
311 |             for ns in namespaces:
312 |                 token_type, group = namespace_into_token_group(ns)
313 |                 logging.debug(
314 |                     f"Namespace mapped into {token_type.name}, group: {group}")
315 | 
316 |                 config_file = all_configs[token_type]
317 |                 if token_type == TokenType.USE_FLAG and (group is None and
318 |                                                          flag is not None):
319 |                     group, flag = split_use_expand(pm, flag)
320 |                     if group is not None:
321 |                         logging.debug(f"Flag remapped into {group}: {flag}")
322 | 
323 |                 for package in packages:
324 |                     if flag is not None and operation.verify_flag:
325 |                         valid_values = get_valid_values(pm, package,
326 |                                                         token_type, group)
327 |                         if valid_values is None:
328 |                             pass
329 |                         elif flag not in valid_values:
330 |                             if not args.force:
331 |                                 argp.error(
332 |                                     f"{op}: argument incorrect for {package}")
333 |                             else:
334 |                                 logging.warning(
335 |                                     f"{op}: argument incorrect for {package}")
336 | 
337 |                     operation.function(config_file, package, group, flag)
338 | 
339 |     diff_prog = shlex.split(args.diff) if args.diff is not None else None
340 | 
341 |     def confirm_cb(orig_file: Path, temp_file: Path) -> bool:
342 |         if diff_prog is not None:
343 |             subprocess.run(diff_prog + [str(orig_file), str(temp_file)])
344 |         return not args.pretend
345 | 
346 |     for config_files in all_configs.values():
347 |         save_config_files(config_files, confirm_cb=confirm_cb)
348 | 
349 |     return 0
350 | 
351 | 
352 | def entry_point() -> None:
353 |     try:
354 |         from rich.logging import RichHandler
355 |     except ImportError:
356 |         logging.basicConfig(
357 |             format="[{levelname:>7}] {message}",
358 |             level=logging.INFO,
359 |             style="{")
360 |     else:
361 |         logging.basicConfig(
362 |             format="{message}",
363 |             level=logging.INFO,
364 |             style="{",
365 |             handlers=[RichHandler(show_time=False, show_path=False)])
366 | 
367 |     sys.exit(main(*sys.argv))
368 | 
369 | 
370 | if __name__ == "__main__":
371 |     entry_point()
372 | 


--------------------------------------------------------------------------------
/flaggie/mangle.py:
--------------------------------------------------------------------------------
  1 | # (c) 2023 Michał Górny
  2 | # Released under the terms of the MIT license
  3 | 
  4 | import functools
  5 | import logging
  6 | import re
  7 | import typing
  8 | 
  9 | from flaggie.config import ConfigFile, ConfigLine
 10 | 
 11 | 
 12 | @functools.cache
 13 | def package_pattern_to_re(pattern: str) -> re.Pattern[str]:
 14 |     """Compile regular expression from wildcard package pattern"""
 15 |     re_str = ".*".join(re.escape(x) for x in pattern.split("*"))
 16 |     return re.compile(re_str)
 17 | 
 18 | 
 19 | def is_wildcard_package(package: str) -> bool:
 20 |     """Check if specified package spec is a wildcard category/package name"""
 21 |     # strip the trailing * from =dev-foo/bar-11*
 22 |     if package.startswith("="):
 23 |         package = package.rstrip("*")
 24 |     return "*" in package
 25 | 
 26 | 
 27 | def is_wildcard_flag(flag: str) -> bool:
 28 |     """Check if specified flag is a proper wildcard"""
 29 |     # TODO: do we need to distinguish per token type?
 30 |     return flag in ("*", "**", "~*") or flag.endswith("_*")
 31 | 
 32 | 
 33 | def match_packages(config_files: list[ConfigFile],
 34 |                    package: str,
 35 |                    exact_match: bool,
 36 |                    ) -> typing.Generator[tuple[ConfigFile, int, ConfigLine],
 37 |                                          None, None]:
 38 |     """
 39 |     Yield matching packages from config files, latest first
 40 | 
 41 |     Iterate over all config file lines, in reverse order and match them
 42 |     against specified package.  If exact_match is True, the package name
 43 |     must match exactly.  Otherwise, wildcard matching (against wildcards
 44 |     in config file) is used.
 45 | 
 46 |     Yields a tuple of (config file object, line number, config line object).
 47 |     """
 48 | 
 49 |     for config_file in reversed(config_files):
 50 |         initial_len = len(config_file.parsed_lines)
 51 |         for rev_no, line in enumerate(reversed(config_file.parsed_lines)):
 52 |             if line.package is None:
 53 |                 continue
 54 | 
 55 |             if exact_match:
 56 |                 if line.package != package:
 57 |                     continue
 58 |             elif package_pattern_to_re(line.package).match(package) is None:
 59 |                 continue
 60 | 
 61 |             # 1-based
 62 |             line_no = initial_len - rev_no
 63 |             yield (config_file, line_no, line)
 64 | 
 65 | 
 66 | def match_flags(line: ConfigLine,
 67 |                 full_name: str,
 68 |                 ) -> typing.Generator[tuple[typing.Optional[str], list[str],
 69 |                                             int], None, None]:
 70 |     """
 71 |     Yield matching flags from specified config line
 72 | 
 73 |     Iterate over flags on the config line, in reverse order and match them
 74 |     against specified full_name ([<prefix>_]<name>).
 75 | 
 76 |     Yields a tuple of (matched group name, list instance, list index).
 77 |     """
 78 | 
 79 |     # FIXME: package files only support '*' after '_' (or in group)
 80 |     full_name_re = package_pattern_to_re(full_name)
 81 | 
 82 |     for group, flags in reversed(line.grouped_flags):
 83 |         group_lc = group.lower()
 84 |         for rev_index, group_flag in enumerate(reversed(flags)):
 85 |             group_flag = f"{group_lc}_{group_flag.lstrip('-')}"
 86 |             # FIXME: as above
 87 |             match = (
 88 |                 package_pattern_to_re(group_flag).match(full_name) is not None)
 89 |             if match or full_name_re.match(group_flag) is not None:
 90 |                 # 0-based
 91 |                 index = len(flags) - rev_index - 1
 92 |                 yield (group_lc, flags, index)
 93 | 
 94 |     for rev_index, line_flag in enumerate(reversed(line.flat_flags)):
 95 |         line_flag = line_flag.lstrip("-")
 96 |         # FIXME: as above
 97 |         match = (
 98 |             package_pattern_to_re(line_flag).match(full_name) is not None)
 99 |         if match or full_name_re.match(line_flag) is not None:
100 |             # 0-based
101 |             index = len(line.flat_flags) - rev_index - 1
102 |             yield (None, line.flat_flags, index)
103 | 
104 | 
105 | class WildcardEntryError(Exception):
106 |     """Exception raised when trying to add a new wildcard entry"""
107 | 
108 |     def __init__(self) -> None:
109 |         super().__init__(
110 |             "Adding wildcard entries other than */* is not supported")
111 | 
112 | 
113 | def insert_sorted(flags: list[str],
114 |                   new_flag: str,
115 |                   ) -> None:
116 |     """Attempt to insert flag to the list preserving sorting"""
117 | 
118 |     new_flag_cmp = new_flag.lstrip("-")
119 |     if new_flag_cmp == "*":
120 |         flags.append(new_flag)
121 |         return
122 | 
123 |     it = enumerate(reversed(flags))
124 |     prev = flags[-1].lstrip("-")
125 |     for i, flag in it:
126 |         flag = flag.lstrip("-")
127 |         if flag > prev:  # not sorted
128 |             break
129 |         elif is_wildcard_flag(flag):  # stop at wildcards
130 |             break
131 |         elif new_flag_cmp > flag:  # the flag should go after
132 |             break
133 |     else:
134 |         # insert at position 0
135 |         i += 1
136 |     flags.insert(len(flags) - i, new_flag)
137 | 
138 | 
139 | def mangle_flag(config_files: list[ConfigFile],
140 |                 package: str,
141 |                 prefix: typing.Optional[str],
142 |                 name: str,
143 |                 new_state: bool,
144 |                 ) -> None:
145 |     """
146 |     Change the effective value of the specified flag
147 | 
148 |     config_files specifies the list of open config files to process.
149 |     package specifies the package name to modify, and can contain `*`
150 |     wildcards as accepted by package.* files.  prefix specifies the flag
151 |     group name (if applicable), or None, while name specifies the name
152 |     within the group.  new_state specifies the expected state (True for
153 |     enabled, False for disabled).
154 | 
155 |     The function tries to do the first possible action from the following:
156 | 
157 |     1. Modify the existing entry specifying the flag state.
158 |     2. Append a new flag to the existing entry for the package.
159 |     3. Append a new entry for the package below the last entry found.
160 |     4. Append a new entry for the package to the end of the last file.
161 |     """
162 | 
163 |     pkg_is_wildcard = is_wildcard_package(package)
164 |     full_name = name if prefix is None else f"{prefix.lower()}_{name}"
165 |     new_state_sym = "" if new_state else "-"
166 | 
167 |     def try_inplace() -> bool:
168 |         for config_file, line_no, line in match_packages(config_files, package,
169 |                                                          pkg_is_wildcard):
170 |             for group_prefix, flag_list, index in match_flags(line, full_name):
171 |                 debug_common = (
172 |                     f"Match found: {config_file.path}:{line_no} "
173 |                     f"{line.package} group: {group_prefix} {flag_list[index]}")
174 |                 # if this was an exact match, we can mangle it in place
175 |                 matched_name = flag_list[index].lstrip("-")
176 |                 matched_flag = (matched_name if group_prefix is None
177 |                                 else f"{group_prefix}_{matched_name}")
178 |                 if line.package == package and matched_flag == full_name:
179 |                     logging.debug(f"{debug_common}, updating in place")
180 |                     flag_list[index] = new_state_sym + matched_name
181 |                     line.invalidate()
182 |                     config_file.modified = True
183 |                     return True
184 |                 logging.debug(
185 |                     f"{debug_common}, non-exact match, cannot update in place")
186 |                 # otherwise, we can't update in-place -- we need to add
187 |                 # after this wildcard
188 |                 return False
189 |         return False
190 | 
191 |     def try_inserting() -> bool:
192 |         for config_file, line_no, line in match_packages(config_files, package,
193 |                                                          pkg_is_wildcard):
194 |             debug_common = (
195 |                 f"Package entry found: {config_file.path}:{line_no} "
196 |                 f"{line.package}")
197 | 
198 |             # require an exact package match, we don't want to update some
199 |             # wildcard entry
200 |             if line.package != package:
201 |                 logging.debug(
202 |                     f"{debug_common}, non-exact match, cannot insert")
203 |                 return False
204 | 
205 |             if prefix is None:
206 |                 # if the line contains grouped flags, we need to create
207 |                 # a new line for the flat flag
208 |                 if line.grouped_flags:
209 |                     logging.debug(
210 |                         f"{debug_common}, ends with flag group, looking "
211 |                         "further")
212 |                     continue
213 |                 insert_sorted(line.flat_flags, new_state_sym + full_name)
214 |                 logging.debug(
215 |                     f"{debug_common}, inserting {new_state_sym}{full_name}")
216 |             else:
217 |                 for group, flags in line.grouped_flags:
218 |                     if group.lower() == prefix.lower():
219 |                         insert_sorted(flags, new_state_sym + name)
220 |                         logging.debug(
221 |                             f"{debug_common}, group {group}, inserting "
222 |                             f"{new_state_sym}{full_name}")
223 |                         break
224 |                 else:
225 |                     logging.debug(
226 |                         f"{debug_common}, prefix unmatched, looking further")
227 |                     continue
228 | 
229 |             line.invalidate()
230 |             config_file.modified = True
231 |             return True
232 |         return False
233 | 
234 |     def try_new_entry_after(new_line: ConfigLine) -> bool:
235 |         for config_file, line_no, line in match_packages(config_files, package,
236 |                                                          pkg_is_wildcard):
237 |             debug_common = (
238 |                 f"Package entry found: {config_file.path}:{line_no} "
239 |                 f"{line.package}")
240 | 
241 |             # again, let's not append after wildcards
242 |             if line.package != package:
243 |                 logging.debug(
244 |                     f"{debug_common}, non-exact match, not appending here")
245 |                 return False
246 | 
247 |             logging.debug(
248 |                 f"Inserting new entry to {config_file.path}, "
249 |                 f"after line {line_no}: {new_line}")
250 |             config_file.parsed_lines.insert(line_no, new_line)
251 |             config_file.modified = True
252 |             return True
253 |         return False
254 | 
255 |     def try_new_entry(new_line: ConfigLine) -> bool:
256 |         assert new_line.package is not None
257 |         if new_line.package == "*/*":
258 |             config_file = config_files[0]
259 |             logging.debug(
260 |                 f"Prepending new entry to {config_file.path}: {new_line}")
261 |             config_file.parsed_lines.insert(0, new_line)
262 |         elif is_wildcard_package(new_line.package):
263 |             raise WildcardEntryError()
264 |         else:
265 |             config_file = config_files[-1]
266 |             logging.debug(
267 |                 f"Appending new entry to {config_file.path}: {new_line}")
268 |             config_file.parsed_lines.append(new_line)
269 |         config_file.modified = True
270 |         return True
271 | 
272 |     if try_inplace() or try_inserting():
273 |         return
274 | 
275 |     new_flag = new_state_sym + name
276 |     if prefix is None:
277 |         new_line = ConfigLine(package, [new_flag], [])
278 |     else:
279 |         new_line = ConfigLine(package, [], [(prefix.upper(), [new_flag])])
280 | 
281 |     try_new_entry_after(new_line) or try_new_entry(new_line)
282 | 
283 | 
284 | def remove_flag(config_files: list[ConfigFile],
285 |                 package: str,
286 |                 prefix: typing.Optional[str],
287 |                 name: typing.Optional[str],
288 |                 ) -> None:
289 |     """
290 |     Remove all entries affecting the specified flag
291 | 
292 |     config_files specifies the list of open config files to process.
293 |     package specifies the package name to modify, and can contain `*`
294 |     wildcards as accepted by package.* files.  prefix specifies the flag
295 |     group name (if applicable), or None, while name specifies the name
296 |     within the group, or None.
297 | 
298 |     If prefix is specified without a name, then all entries affecting
299 |     the specific group are removed.  If neither prefix nor name are
300 |     specified, all entries for the specified package are removed.
301 | 
302 |     Wildcard specifications within package and flag names are not
303 |     processed, that is only entries specifying exactly the same wildcard
304 |     are affected.  Therefore, e.g. name="*" will only remove the entry
305 |     for `*` and not all flags matching it.
306 |     """
307 | 
308 |     if prefix is not None:
309 |         prefix_lc = prefix.lower()
310 |     if name is not None:
311 |         full_name = name if prefix is None else f"{prefix_lc}_{name}"
312 | 
313 |     for config_file, line_no, line in match_packages(config_files, package,
314 |                                                      True):
315 |         logging.debug(f"Package entry found: {config_file.path}:{line_no} "
316 |                       f"{line.package}")
317 | 
318 |         class shared:
319 |             matched = False
320 | 
321 |         def filter_by_full(flag: str) -> bool:
322 |             if flag.lstrip("-") == full_name:
323 |                 logging.debug(f"Removing {flag}")
324 |                 shared.matched = True
325 |                 return False
326 |             return True
327 | 
328 |         def filter_by_prefix(flag: str) -> bool:
329 |             if flag.lstrip("-").startswith(f"{prefix_lc}_"):
330 |                 logging.debug(f"Removing {flag}")
331 |                 shared.matched = True
332 |                 return False
333 |             return True
334 | 
335 |         def filter_by_name(flag: str) -> bool:
336 |             if flag.lstrip("-") == name:
337 |                 logging.debug(f"Removing {prefix}: {flag}")
338 |                 shared.matched = True
339 |                 return False
340 |             return True
341 | 
342 |         def filter_empty_groups(group: tuple[str, list[str]]) -> bool:
343 |             return bool(group[1]) or group[0].lower() != prefix_lc
344 | 
345 |         if name is not None:
346 |             line.flat_flags = list(filter(filter_by_full, line.flat_flags))
347 |         elif prefix is not None:
348 |             line.flat_flags = list(filter(filter_by_prefix, line.flat_flags))
349 |         else:
350 |             logging.debug("Removing all flags")
351 |             line.flat_flags.clear()
352 |             line.grouped_flags.clear()
353 |             shared.matched = True
354 | 
355 |         if prefix is not None:
356 |             for group, values in line.grouped_flags:
357 |                 if group.lower() == prefix_lc:
358 |                     if name is not None:
359 |                         values[:] = list(filter(filter_by_name, values))
360 |                     else:
361 |                         values.clear()
362 |                         shared.matched = True
363 |             line.grouped_flags = list(filter(filter_empty_groups,
364 |                                              line.grouped_flags))
365 | 
366 |         if shared.matched:
367 |             line.invalidate()
368 |             config_file.modified = True
369 |             # remove the lines that are now empty
370 |             if not line.flat_flags and not line.grouped_flags:
371 |                 del config_file.parsed_lines[line_no - 1]
372 | 


--------------------------------------------------------------------------------
/test/test_mangle.py:
--------------------------------------------------------------------------------
  1 | # (c) 2023 Michał Górny
  2 | # Released under the terms of the MIT license
  3 | 
  4 | import itertools
  5 | import typing
  6 | 
  7 | from pathlib import Path
  8 | 
  9 | import pytest
 10 | 
 11 | from flaggie.config import ConfigFile, ConfigLine, parse_config_file
 12 | from flaggie.mangle import (mangle_flag, remove_flag, WildcardEntryError,
 13 |                             package_pattern_to_re, is_wildcard_package,
 14 |                             is_wildcard_flag, insert_sorted,
 15 |                             )
 16 | 
 17 | 
 18 | def get_config(raw_data: list[str]) -> list[ConfigFile]:
 19 |     return [ConfigFile(Path("test.conf"), list(parse_config_file(raw_data)))]
 20 | 
 21 | 
 22 | def get_modified_line_nos(config_file: ConfigFile) -> frozenset[int]:
 23 |     def inner() -> typing.Generator[int, None, None]:
 24 |         for line_no, line in enumerate(config_file.parsed_lines):
 25 |             if line._raw_line is None:
 26 |                 yield line_no
 27 | 
 28 |     assert config_file.modified
 29 |     return frozenset(inner())
 30 | 
 31 | 
 32 | def param_new() -> pytest.MarkDecorator:
 33 |     return pytest.mark.parametrize("new", ["-foo", "foo"])
 34 | 
 35 | 
 36 | def param_old_new(*, prefix: str = "", flag: str = "foo",
 37 |                   ) -> pytest.MarkDecorator:
 38 |     return pytest.mark.parametrize(
 39 |         "old,new",
 40 |         itertools.product([f"-{prefix}{flag}", f"{prefix}{flag}"], repeat=2))
 41 | 
 42 | 
 43 | def param_pkg(include_global: bool = False) -> pytest.MarkDecorator:
 44 |     return pytest.mark.parametrize(
 45 |         "package", ["dev-foo/foo", "dev-bar/*"] +
 46 |         (["*/*"] if include_global else []))
 47 | 
 48 | 
 49 | @param_old_new()
 50 | @param_pkg(include_global=True)
 51 | def test_toggle_flag(old, new, package):
 52 |     config = get_config(["*/* foo",
 53 |                          "",
 54 |                          f"{package} {old} bar",
 55 |                          "dev-foo/bar foo",
 56 |                          f"{package} baz",
 57 |                          ])
 58 |     mangle_flag(config, package, None, new.lstrip("-"),
 59 |                 not new.startswith("-"))
 60 |     assert get_modified_line_nos(config[0]) == {2}
 61 |     assert config[0].parsed_lines == [
 62 |         ConfigLine("*/*", ["foo"]),
 63 |         ConfigLine(),
 64 |         ConfigLine(package, [new, "bar"]),
 65 |         ConfigLine("dev-foo/bar", ["foo"]),
 66 |         ConfigLine(package, ["baz"]),
 67 |     ]
 68 | 
 69 | 
 70 | @param_new()
 71 | @param_pkg()
 72 | def test_toggle_flag_append(new, package):
 73 |     config = get_config(["*/* foo",
 74 |                          "",
 75 |                          f"{package} bar",
 76 |                          "dev-foo/bar foo",
 77 |                          f"{package} baz",
 78 |                          f"{package} GROUP: other",
 79 |                          ])
 80 |     mangle_flag(config, package, None, new.lstrip("-"),
 81 |                 not new.startswith("-"))
 82 |     assert get_modified_line_nos(config[0]) == {4}
 83 |     assert config[0].parsed_lines == [
 84 |         ConfigLine("*/*", ["foo"]),
 85 |         ConfigLine(),
 86 |         ConfigLine(package, ["bar"]),
 87 |         ConfigLine("dev-foo/bar", ["foo"]),
 88 |         ConfigLine(package, ["baz", new]),
 89 |         ConfigLine(package, [], [("GROUP", ["other"])]),
 90 |     ]
 91 | 
 92 | 
 93 | @param_new()
 94 | @param_pkg(include_global=True)
 95 | def test_toggle_flag_append_to_group(new, package):
 96 |     config = get_config(["*/* foo",
 97 |                          "",
 98 |                          f"{package} GROUP: bar",
 99 |                          "dev-foo/bar foo",
100 |                          f"{package} group_baz",
101 |                          ])
102 |     mangle_flag(config, package, "group", new.lstrip("-"),
103 |                 not new.startswith("-"))
104 |     assert get_modified_line_nos(config[0]) == {2}
105 |     assert config[0].parsed_lines == [
106 |         ConfigLine("*/*", ["foo"]),
107 |         ConfigLine(),
108 |         ConfigLine(package, [], [("GROUP", ["bar", new])]),
109 |         ConfigLine("dev-foo/bar", ["foo"]),
110 |         ConfigLine(package, ["group_baz"]),
111 |     ]
112 | 
113 | 
114 | @param_new()
115 | def test_toggle_flag_new_entry(new):
116 |     config = get_config(["*/* foo",
117 |                          "dev-foo/bar foo",
118 |                          ])
119 |     mangle_flag(config, "dev-foo/foo", None, new.lstrip("-"),
120 |                 not new.startswith("-"))
121 |     assert get_modified_line_nos(config[0]) == {2}
122 |     assert config[0].parsed_lines == [
123 |         ConfigLine("*/*", ["foo"]),
124 |         ConfigLine("dev-foo/bar", ["foo"]),
125 |         ConfigLine("dev-foo/foo", [new]),
126 |     ]
127 | 
128 | 
129 | @param_new()
130 | def test_toggle_flag_new_entry_global(new):
131 |     config = get_config(["dev-foo/bar foo",
132 |                          ])
133 |     mangle_flag(config, "*/*", None, new.lstrip("-"),
134 |                 not new.startswith("-"))
135 |     assert get_modified_line_nos(config[0]) == {0}
136 |     assert config[0].parsed_lines == [
137 |         ConfigLine("*/*", [new]),
138 |         ConfigLine("dev-foo/bar", ["foo"]),
139 |     ]
140 | 
141 | 
142 | @param_new()
143 | def test_toggle_flag_new_entry_wildcard(new):
144 |     config = get_config(["dev-foo/bar foo",
145 |                          ])
146 |     with pytest.raises(WildcardEntryError):
147 |         mangle_flag(config, "dev-foo/*", None, new.lstrip("-"),
148 |                     not new.startswith("-"))
149 | 
150 | 
151 | @param_new()
152 | @param_pkg(include_global=True)
153 | def test_toggle_flag_new_entry_because_of_group(new, package):
154 |     config = get_config([f"{package} GROUP: baz",
155 |                          "dev-foo/bar foo",
156 |                          ])
157 |     mangle_flag(config, package, None, new.lstrip("-"),
158 |                 not new.startswith("-"))
159 |     assert get_modified_line_nos(config[0]) == {1}
160 |     assert config[0].parsed_lines == [
161 |         ConfigLine(package, [], [("GROUP", ["baz"])]),
162 |         ConfigLine(package, [new]),
163 |         ConfigLine("dev-foo/bar", ["foo"]),
164 |     ]
165 | 
166 | 
167 | @param_new()
168 | @param_pkg(include_global=True)
169 | def test_toggle_flag_new_entry_group(new, package):
170 |     config = get_config([f"{package} group_baz",
171 |                          "dev-foo/bar foo",
172 |                          ])
173 |     mangle_flag(config, package, "group", new.lstrip("-"),
174 |                 not new.startswith("-"))
175 |     assert get_modified_line_nos(config[0]) == {1}
176 |     assert config[0].parsed_lines == [
177 |         ConfigLine(package, ["group_baz"]),
178 |         ConfigLine(package, [], [("GROUP", [new])]),
179 |         ConfigLine("dev-foo/bar", ["foo"]),
180 |     ]
181 | 
182 | 
183 | @param_old_new(prefix="group_")
184 | @param_pkg(include_global=True)
185 | def test_toggle_flag_in_group(old, new, package):
186 |     config = get_config(["*/* foo",
187 |                          "",
188 |                          f"{package} {old} group_bar",
189 |                          "dev-foo/bar foo",
190 |                          f"{package} GROUP: baz",
191 |                          ])
192 |     assert new.lstrip("-").startswith("group_")
193 |     mangle_flag(config, package, "group", new.lstrip("-")[6:],
194 |                 not new.startswith("-"))
195 |     assert get_modified_line_nos(config[0]) == {2}
196 |     assert config[0].parsed_lines == [
197 |         ConfigLine("*/*", ["foo"]),
198 |         ConfigLine(),
199 |         ConfigLine(package, [new, "group_bar"]),
200 |         ConfigLine("dev-foo/bar", ["foo"]),
201 |         ConfigLine(package, [], [("GROUP", ["baz"])]),
202 |     ]
203 | 
204 | 
205 | @param_old_new()
206 | @pytest.mark.parametrize("group", ["Group", "GROUP"])
207 | @param_pkg(include_global=True)
208 | def test_toggle_flag_in_group_verbose(old, new, group, package):
209 |     config = get_config(["*/* foo",
210 |                          "",
211 |                          f"{package} {group}: {old} bar",
212 |                          "dev-foo/bar foo",
213 |                          f"{package} group_baz",
214 |                          ])
215 |     mangle_flag(config, package, "group", new.lstrip("-"),
216 |                 not new.startswith("-"))
217 |     assert get_modified_line_nos(config[0]) == {2}
218 |     assert config[0].parsed_lines == [
219 |         ConfigLine("*/*", ["foo"]),
220 |         ConfigLine(),
221 |         ConfigLine(package, [], [(group, [new, "bar"])]),
222 |         ConfigLine("dev-foo/bar", ["foo"]),
223 |         ConfigLine(package, ["group_baz"]),
224 |     ]
225 | 
226 | 
227 | @param_old_new(flag="*")
228 | @param_pkg()
229 | def test_toggle_wildcard_flag(old, new, package):
230 |     config = get_config(["*/* foo",
231 |                          "",
232 |                          f"{package} {old}",
233 |                          ])
234 |     mangle_flag(config, package, None, new.lstrip("-"),
235 |                 not new.startswith("-"))
236 |     assert get_modified_line_nos(config[0]) == {2}
237 |     assert config[0].parsed_lines == [
238 |         ConfigLine("*/*", ["foo"]),
239 |         ConfigLine(),
240 |         ConfigLine(package, [new]),
241 |     ]
242 | 
243 | 
244 | @param_old_new(prefix="group_", flag="*")
245 | @param_pkg()
246 | def test_toggle_wildcard_flag_group(old, new, package):
247 |     config = get_config(["*/* foo",
248 |                          "",
249 |                          f"{package} {old}",
250 |                          ])
251 |     mangle_flag(config, package, "group", new.lstrip("-")[6:],
252 |                 not new.startswith("-"))
253 |     assert get_modified_line_nos(config[0]) == {2}
254 |     assert config[0].parsed_lines == [
255 |         ConfigLine("*/*", ["foo"]),
256 |         ConfigLine(),
257 |         ConfigLine(package, [new]),
258 |     ]
259 | 
260 | 
261 | @param_old_new(flag="*")
262 | @param_pkg()
263 | def test_toggle_wildcard_flag_group_verbose(old, new, package):
264 |     config = get_config(["*/* foo",
265 |                          "",
266 |                          f"{package} GROUP: {old}",
267 |                          ])
268 |     mangle_flag(config, package, "group", new.lstrip("-"),
269 |                 not new.startswith("-"))
270 |     assert get_modified_line_nos(config[0]) == {2}
271 |     assert config[0].parsed_lines == [
272 |         ConfigLine("*/*", ["foo"]),
273 |         ConfigLine(),
274 |         ConfigLine(package, [], [("GROUP", [new])]),
275 |     ]
276 | 
277 | 
278 | @param_old_new(flag="*")
279 | @pytest.mark.parametrize("other", ["bar", "group_foo"])
280 | @param_pkg()
281 | def test_toggle_wildcard_flag_non_final(old, new, other, package):
282 |     config = get_config(["*/* foo",
283 |                          "",
284 |                          f"{package} {old} {other}",
285 |                          ])
286 |     mangle_flag(config, package, None, new.lstrip("-"),
287 |                 not new.startswith("-"))
288 |     assert get_modified_line_nos(config[0]) == {2}
289 |     assert config[0].parsed_lines == [
290 |         ConfigLine("*/*", ["foo"]),
291 |         ConfigLine(),
292 |         ConfigLine(package, [old, other, new]),
293 |     ]
294 | 
295 | 
296 | @param_old_new(flag="*")
297 | @param_pkg()
298 | def test_toggle_wildcard_flag_non_final_because_of_group(old, new, package):
299 |     config = get_config(["*/* foo",
300 |                          "",
301 |                          f"{package} {old} GROUP: bar",
302 |                          ])
303 |     mangle_flag(config, package, None, new.lstrip("-"),
304 |                 not new.startswith("-"))
305 |     assert get_modified_line_nos(config[0]) == {3}
306 |     assert config[0].parsed_lines == [
307 |         ConfigLine("*/*", ["foo"]),
308 |         ConfigLine(),
309 |         ConfigLine(package, [old], [("GROUP", ["bar"])]),
310 |         ConfigLine(package, [new]),
311 |     ]
312 | 
313 | 
314 | @param_old_new(prefix="group_", flag="*")
315 | @param_pkg()
316 | def test_toggle_wildcard_flag_group_non_final(old, new, package):
317 |     config = get_config(["*/* foo",
318 |                          "",
319 |                          f"{package} {old} bar",
320 |                          ])
321 |     mangle_flag(config, package, "group", new.lstrip("-")[6:],
322 |                 not new.startswith("-"))
323 |     assert get_modified_line_nos(config[0]) == {2}
324 |     assert config[0].parsed_lines == [
325 |         ConfigLine("*/*", ["foo"]),
326 |         ConfigLine(),
327 |         ConfigLine(package, [new, "bar"]),
328 |     ]
329 | 
330 | 
331 | @param_old_new(flag="*")
332 | @param_pkg()
333 | def test_toggle_wildcard_flag_group_verbose_non_final(old, new, package):
334 |     config = get_config(["*/* foo",
335 |                          "",
336 |                          f"{package} GROUP: {old}",
337 |                          f"{package} bar",
338 |                          ])
339 |     mangle_flag(config, package, "group", new.lstrip("-"),
340 |                 not new.startswith("-"))
341 |     assert get_modified_line_nos(config[0]) == {2}
342 |     assert config[0].parsed_lines == [
343 |         ConfigLine("*/*", ["foo"]),
344 |         ConfigLine(),
345 |         ConfigLine(package, [], [("GROUP", [new])]),
346 |         ConfigLine(package, ["bar"]),
347 |     ]
348 | 
349 | 
350 | @pytest.mark.parametrize(
351 |     "pattern,expected",
352 |     [("dev-foo/bar", r"dev\-foo/bar"),
353 |      ("dev-*/bar", r"dev\-.*/bar"),
354 |      ("*/*", r".*/.*"),
355 |      ("*/foo", r".*/foo"),
356 |      ("x11-libs/gtk+", r"x11\-libs/gtk\+"),
357 |      ("[0-9]+", r"\[0\-9\]\+"),
358 |      ("?*?", r"\?.*\?"),
359 |      ])
360 | def test_package_pattern_to_re(pattern, expected):
361 |     assert package_pattern_to_re(pattern).pattern == expected
362 | 
363 | 
364 | @pytest.mark.parametrize(
365 |     "package,expected",
366 |     [("dev-foo/bar", False),
367 |      ("dev-foo/*", True),
368 |      ("*/*", True),
369 |      ("=dev-foo/bar-11*", False),
370 |      ])
371 | def test_is_wildcard_package(package, expected):
372 |     assert is_wildcard_package(package) == expected
373 | 
374 | 
375 | @param_pkg()
376 | def test_remove_flag(package):
377 |     config = get_config(["*/* foo GROUP: foo",
378 |                          "",
379 |                          f"{package} foo bar GROUP: foo",
380 |                          "dev-foo/bar foo",
381 |                          f"{package} baz -foo group_foo",
382 |                          f"{package} -foo",
383 |                          ])
384 |     remove_flag(config, package, None, "foo")
385 |     assert get_modified_line_nos(config[0]) == {2, 4}
386 |     assert config[0].parsed_lines == [
387 |         ConfigLine("*/*", ["foo"], [("GROUP", ["foo"])]),
388 |         ConfigLine(),
389 |         ConfigLine(package, ["bar"], [("GROUP", ["foo"])]),
390 |         ConfigLine("dev-foo/bar", ["foo"]),
391 |         ConfigLine(package, ["baz", "group_foo"]),
392 |     ]
393 | 
394 | 
395 | @param_pkg()
396 | def test_remove_flag_in_group(package):
397 |     config = get_config(["*/* foo GROUP: foo",
398 |                          "",
399 |                          f"{package} foo bar GROUP: foo bar GROUP: -foo",
400 |                          "dev-foo/bar foo",
401 |                          f"{package} baz foo group_foo",
402 |                          f"{package} -group_foo GROUP: foo",
403 |                          ])
404 |     remove_flag(config, package, "group", "foo")
405 |     assert get_modified_line_nos(config[0]) == {2, 4}
406 |     assert config[0].parsed_lines == [
407 |         ConfigLine("*/*", ["foo"], [("GROUP", ["foo"])]),
408 |         ConfigLine(),
409 |         ConfigLine(package, ["foo", "bar"], [("GROUP", ["bar"])]),
410 |         ConfigLine("dev-foo/bar", ["foo"]),
411 |         ConfigLine(package, ["baz", "foo"]),
412 |     ]
413 | 
414 | 
415 | @param_pkg()
416 | def test_remove_all_in_group(package):
417 |     config = get_config(["*/* foo GROUP: foo",
418 |                          "",
419 |                          f"{package} foo bar GROUP: foo -bar GROUP: foo",
420 |                          "dev-foo/bar foo",
421 |                          f"{package} baz foo group_foo",
422 |                          f"{package} group_foo GROUP: foo",
423 |                          ])
424 |     remove_flag(config, package, "group", None)
425 |     assert get_modified_line_nos(config[0]) == {2, 4}
426 |     assert config[0].parsed_lines == [
427 |         ConfigLine("*/*", ["foo"], [("GROUP", ["foo"])]),
428 |         ConfigLine(),
429 |         ConfigLine(package, ["foo", "bar"]),
430 |         ConfigLine("dev-foo/bar", ["foo"]),
431 |         ConfigLine(package, ["baz", "foo"]),
432 |     ]
433 | 
434 | 
435 | @param_pkg()
436 | def test_remove_all(package):
437 |     config = get_config(["*/* foo GROUP: foo",
438 |                          "",
439 |                          f"{package} foo -bar GROUP: foo bar GROUP: foo",
440 |                          "dev-foo/bar foo",
441 |                          f"{package} baz -foo group_foo",
442 |                          f"{package} group_foo GROUP: -foo",
443 |                          ])
444 |     remove_flag(config, package, None, None)
445 |     assert get_modified_line_nos(config[0]) == set()
446 |     assert config[0].parsed_lines == [
447 |         ConfigLine("*/*", ["foo"], [("GROUP", ["foo"])]),
448 |         ConfigLine(),
449 |         ConfigLine("dev-foo/bar", ["foo"]),
450 |     ]
451 | 
452 | 
453 | @pytest.mark.parametrize(
454 |     "flag,expected",
455 |     [("foo", False),
456 |      ("*", True),
457 |      ("*foo", False),
458 |      ("foo*", False),
459 |      ("foo_*", True),
460 |      ("**", True),
461 |      ("~*", True),
462 |      ])
463 | def test_is_wildcard_flag(flag: str, expected: bool) -> None:
464 |     assert is_wildcard_flag(flag) == expected
465 | 
466 | 
467 | @pytest.mark.parametrize(
468 |     "flags,new_flag,expected",
469 |     [(["a", "c", "e"], "b", ["a", "b", "c", "e"]),
470 |      (["a", "c", "e"], "d", ["a", "c", "d", "e"]),
471 |      (["a", "c", "e"], "f", ["a", "c", "e", "f"]),
472 |      (["b", "c", "d"], "a", ["a", "b", "c", "d"]),
473 |      (["b", "*", "c"], "a", ["b", "*", "a", "c"]),
474 |      (["b", "*"], "a", ["b", "*", "a"]),
475 |      (["*"], "a", ["*", "a"]),
476 |      (["a"], "*", ["a", "*"]),
477 |      (["*", "a"], "*", ["*", "a", "*"]),
478 |      ])
479 | def test_insert_sorted(flags: list[str],
480 |                        new_flag: str,
481 |                        expected: list[str],
482 |                        ) -> None:
483 |     insert_sorted(flags, new_flag)
484 |     assert flags == expected
485 | 


--------------------------------------------------------------------------------