Upgrade configuration syntax to v4 (#146)

Author: gaborbernat

pyproject.toml

@@ -43,6 +43,9 @@ classifiers = [
 dynamic = [
   "version",
 ]
+dependencies = [
+  "packaging>=23",
+]
 optional-dependencies.test = [
   "covdefaults>=2.3",
   "pytest>=7.2.2",

src/tox_ini_fmt/__main__.py

@@ -50,8 +50,8 @@ def run(args: Sequence[str] | None = None) -> int:
                 else []
             )
             if diff:
-                diff = color_diff(diff)
-                print("\n".join(diff))  # print diff on change
+                diff_text = "\n".join(color_diff(diff))
+                print(diff_text)  # print diff on change
             else:
                 print(f"no change for {name}")
     # exit with non success on change

src/tox_ini_fmt/formatter/__init__.py

@@ -23,11 +23,11 @@ def format_tox_ini(tox_ini: str | Path, opts: ToxIniFmtNamespace | None = None)
         text = tox_ini
     parser.read_string(text)
 
-    order_sections(parser, opts.pin_toxenvs)
     format_tox_section(parser, opts.pin_toxenvs)
     for section_name in parser.sections():
         if section_name == "testenv" or section_name.startswith("testenv:"):
             format_test_env(parser, section_name)
+    order_sections(parser, opts.pin_toxenvs)
 
     return _generate_tox_ini(parser)
 

src/tox_ini_fmt/formatter/requires.py

@@ -1,40 +1,36 @@
 from __future__ import annotations
 
-import re
+from packaging.requirements import InvalidRequirement, Requirement
 
-BASE_NAME_REGEX = re.compile(r"[^!=><~\s@]+")
-REQ_REGEX = re.compile(r"(===|==|!=|~=|>=?|<=?|@)\s*([^,]+)")
+
+def normalize_req(req: str) -> str:
+    try:
+        parsed = Requirement(req)
+    except InvalidRequirement:
+        return req
+
+    for spec in parsed.specifier:
+        if spec.operator in (">=", "=="):
+            version = spec.version
+            while version.endswith(".0"):
+                version = version[:-2]
+                spec._spec = (spec._spec[0], version)
+    return str(parsed)
+
+
+def _req_name(req: str) -> str:
+    try:
+        return Requirement(req).name
+    except InvalidRequirement:
+        return req
 
 
 def requires(raws: list[str]) -> list[str]:
-    values = (_normalize_req(req) for req in raws if req)
-    normalized = sorted(values, key=lambda req: (";" in req, _req_base(req), req))
+    values = (normalize_req(req) for req in raws if req)
+    normalized = sorted(values, key=lambda req: (";" in req, _req_name(req), req))
     return normalized
 
 
-def _normalize_req(req: str) -> str:
-    lib, _, envs = req.partition(";")
-    normalized = _normalize_lib(lib)
-    envs = envs.strip()
-    if not envs:
-        return normalized
-    return f"{normalized};{envs}"
-
-
-def _normalize_lib(lib: str) -> str:
-    base = _req_base(lib)
-    values = sorted(
-        (f"{m.group(1)}{m.group(2)}" for m in REQ_REGEX.finditer(lib)),
-        key=lambda c: ("<" in c, ">" in "c", c),
-    )
-    if values:  # strip .0 version
-        while values[0].endswith(".0") and (values[0].startswith(">=") or values[0].startswith("==")):
-            values[0] = values[0][:-2]
-    return f"{base}{','.join(values)}"
-
-
-def _req_base(lib: str) -> str:
-    match = re.match(BASE_NAME_REGEX, lib)
-    if match is None:
-        raise ValueError(repr(lib))
-    return match.group(0)
+__all__ = [
+    "requires",
+]

src/tox_ini_fmt/formatter/section_order.py

@@ -25,8 +25,6 @@ def order_sections(parser: ConfigParser, pin_toxenvs: list[str]) -> None:
 
 
 def load_and_order_env_list(parser: ConfigParser, pin_toxenvs: list[str]) -> list[str]:
-    if not parser.has_section("tox"):
-        return []
     result: list[str] = next(
         (explode_env_list(parser["tox"][i]) for i in ("envlist", "env_list") if i in parser["tox"]),
         [],

src/tox_ini_fmt/formatter/test_env.py

@@ -12,20 +12,15 @@ def format_test_env(parser: ConfigParser, name: str) -> None:
         "runner": str,
         "description": str,
         "base_python": str,
-        "basepython": str,
         "system_site_packages": to_boolean,
-        "sitepackages": to_boolean,
         "always_copy": to_boolean,
-        "alwayscopy": to_boolean,
         "download": to_boolean,
         "package": str,
         "package_env": str,
         "wheel_build_env": str,
         "package_tox_env_type": str,
         "package_root": str,
         "skip_install": to_boolean,
-        "use_develop": to_boolean,
-        "usedevelop": to_boolean,
         "meta_dir": str,
         "pkg_dir": str,
         "pip_pre": to_boolean,
@@ -34,11 +29,9 @@ def format_test_env(parser: ConfigParser, name: str) -> None:
         "recreate": to_boolean,
         "parallel_show_output": to_boolean,
         "pass_env": to_pass_env,
-        "passenv": to_pass_env,
         "set_env": to_set_env,
         "setenv": to_set_env,
         "change_dir": str,
-        "changedir": str,
         "args_are_paths": to_boolean,
         "ignore_errors": to_boolean,
         "ignore_outcome": to_boolean,
@@ -51,7 +44,25 @@ def format_test_env(parser: ConfigParser, name: str) -> None:
         "terminate_timeout": str,
         "depends": partial(to_list_of_env_values, []),
     }
-    fix_and_reorder(parser, name, tox_section_cfg)
+    upgrade = {
+        "envdir": "env_dir",
+        "envtmpdir": "env_tmp_dir",
+        "envlogdir": "env_log_dir",
+        "passenv": "pass_env",
+        "setenv": "set_env",
+        "changedir": "change_dir",
+        "basepython": "base_python",
+        "setupdir": "package_root",
+        "sitepackages": "system_site_packages",
+        "alwayscopy": "always_copy",
+    }
+
+    section = parser[name]
+    use_develop = next((section.pop(i) for i in ("usedevelop", "use_develop") if i in section), "false")
+    if to_boolean(use_develop) == "true":
+        parser[name]["package"] = "editable"
+
+    fix_and_reorder(parser, name, tox_section_cfg, upgrade)
 
 
 def to_ordered_list(value: str) -> str:

src/tox_ini_fmt/formatter/tox_section.py

@@ -1,29 +1,67 @@
 from __future__ import annotations
 
-from configparser import ConfigParser
+from configparser import ConfigParser, SectionProxy
 from functools import partial
 from typing import Callable, Mapping
 
-from .util import fix_and_reorder, to_boolean, to_list_of_env_values, to_py_dependencies
+from packaging.requirements import Requirement
+from packaging.version import Version
+
+from .requires import requires
+from .util import collect_multi_line, fix_and_reorder, to_boolean, to_list_of_env_values, to_py_dependencies
 
 
 def format_tox_section(parser: ConfigParser, pin_toxenvs: list[str]) -> None:
     if not parser.has_section("tox"):
-        return
+        parser.add_section("tox")
+    tox = parser["tox"]
+    _handle_min_version(tox)
+    tox.pop("isolated_build", None)
+
     tox_section_cfg: Mapping[str, Callable[[str], str]] = {
-        "minversion": str,
         "min_version": str,
         "requires": to_py_dependencies,
         "provision_tox_env": str,
         "env_list": partial(to_list_of_env_values, pin_toxenvs),
-        "envlist": partial(to_list_of_env_values, pin_toxenvs),
-        "isolated_build": to_boolean,
         "package_env": str,
         "isolated_build_env": str,
         "no_package": to_boolean,
-        "skipsdist": to_boolean,
         "skip_missing_interpreters": to_boolean,
         "ignore_base_python_conflict": to_boolean,
-        "ignore_basepython_conflict": to_boolean,
     }
-    fix_and_reorder(parser, "tox", tox_section_cfg)
+    upgrade = {
+        "envlist": "env_list",
+        "toxinidir": "tox_root",
+        "toxworkdir": "work_dir",
+        "skipsdist": "no_package",
+        "isolated_build_env": "package_env",
+        "setupdir": "package_root",
+        "ignore_basepython_conflict": "ignore_base_python_conflict",
+    }
+    fix_and_reorder(parser, "tox", tox_section_cfg, upgrade)
+
+
+def _handle_min_version(tox: SectionProxy) -> None:
+    min_version = next((tox.pop(i) for i in ("minversion", "min_version") if i in tox), None)
+    if min_version is None or int(min_version.split(".")[0]) < 4:
+        min_version = "4.2"
+    tox_requires = [
+        Requirement(i)
+        for i in collect_multi_line(
+            tox.get("requires", ""),
+            line_split=None,
+            normalize=lambda groups: {k: requires(v) for k, v in groups.items()},
+        )[0]
+    ]
+    for _at, entry in enumerate(tox_requires):
+        if entry.name == "tox":
+            break
+    else:
+        _at = -1
+    if _at == -1:
+        tox_requires.append(Requirement(f"tox>={min_version}"))
+    else:
+        specifiers = list(tox_requires[_at].specifier)
+        if len(specifiers) == 0 or Version(specifiers[0].version) < Version(min_version):
+            tox_requires[_at] = Requirement(f"tox>={min_version}")
+    tox["requires"] = "\n".join(str(i) for i in tox_requires)

src/tox_ini_fmt/formatter/util.py

@@ -14,8 +14,20 @@ def to_boolean(payload: str) -> str:
     return "true" if payload.lower() == "true" else "false"
 
 
-def fix_and_reorder(parser: ConfigParser, name: str, fix_cfg: Mapping[str, Callable[[str], str]]) -> None:
+def fix_and_reorder(
+    parser: ConfigParser,
+    name: str,
+    fix_cfg: Mapping[str, Callable[[str], str]],
+    upgrade: dict[str, str],
+) -> None:
     section = parser[name]
+    # upgrade
+    for key, to in upgrade.items():
+        if key in section:
+            if to in section:
+                raise RuntimeError(f"upgrade alias {to} also present for {key}")
+            section[to] = section.pop(key)
+    # normalize
     for key, fix in fix_cfg.items():
         if key in section:
             section[key] = fix(section[key])

tests/formatter/test_line_endings.py

@@ -13,15 +13,15 @@ def test_platform_default(tox_ini: Path) -> None:
 
     tox_ini.write_bytes(b"[tox]")
     run([str(tox_ini)])
-    assert tox_ini.read_bytes() == f"[tox]{os.linesep}".encode()
+    assert tox_ini.read_bytes() == f"[tox]{os.linesep}requires ={os.linesep}    tox>=4.2{os.linesep}".encode()
 
 
 @pytest.mark.parametrize("newline", ["\r\n", "\n", "\r"])
 def test_line_endings(tox_ini: Path, newline: str) -> None:
     """The ini file's existing newlines must be respected when reformatting."""
 
-    original_text = f"[tox]{newline}envlist=py39"
-    expected_text = f"[tox]{newline}envlist ={newline}    py39{newline}"
+    original_text = f"[tox]{newline}requires ={newline}    tox>=4.2{newline}env_list=py39"
+    expected_text = f"[tox]{newline}requires ={newline}    tox>=4.2{newline}env_list ={newline}    py39{newline}"
     tox_ini.write_bytes(original_text.encode("utf8"))
     run([str(tox_ini)])
     assert tox_ini.read_bytes() == expected_text.encode("utf8")
@@ -34,8 +34,8 @@ def test_mixed_line_endings(tox_ini: Path) -> None:
     Python does not report the newlines in the order they're encountered.
     """
 
-    original_text = "[tox]\r\n \r \nenvlist=py39"
-    expected_text = "[tox]!!envlist =!!    py39!!"
+    original_text = "[tox]\r\n \r \nenv_list=py39"
+    expected_text = "[tox]!!requires =!!    tox>=4.2!!env_list =!!    py39!!"
     tox_ini.write_bytes(original_text.encode("utf8"))
     with tox_ini.open("rt") as file:
         file.read()

tests/formatter/test_requires.py

@@ -21,8 +21,8 @@
             "pytest-xdist>=1.31.0\n",
             [
                 "pytest-xdist>=1.31",
-                'packaging>=20;python_version>"3.4"',
-                "xonsh>=0.9.16;python_version > '3.4' and python_version != '3.9'",
+                'packaging>=20; python_version > "3.4"',
+                'xonsh>=0.9.16; python_version > "3.4" and python_version != "3.9"',
             ],
         ),
         ("pytest>=6.0.0", ["pytest>=6"]),
@@ -33,20 +33,3 @@
 def test_requires_fmt(value: str, result: list[str]) -> None:
     outcome = requires([i.strip() for i in value.splitlines() if i.strip()])
     assert outcome == result
-
-
-@pytest.mark.parametrize(
-    "char",
-    [
-        "!",
-        "=",
-        ">",
-        "<",
-        " ",
-        "\t",
-        "@",
-    ],
-)
-def test_bad_syntax_requires(char: str) -> None:
-    with pytest.raises(ValueError, match=f"[{char}]" if char.strip() else None):
-        requires([f"{char};"])

tests/formatter/test_section_order.py

@@ -37,7 +37,7 @@ def test_section_order(tox_ini: Path) -> None:
         [magic]
         i = j
         [tox]
-        envlist = py38,py37
+        env_list = py38,py37
         e = f
 
         """,
@@ -48,7 +48,9 @@ def test_section_order(tox_ini: Path) -> None:
     expected = dedent(
         """
         [tox]
-        envlist =
+        requires =
+            tox>=4.2
+        env_list =
             py38
             py37
         e = f
@@ -70,15 +72,15 @@ def test_section_order(tox_ini: Path) -> None:
 
 
 def test_pin_missing(tox_ini: Path) -> None:
-    tox_ini.write_text("[tox]\nenvlist=py")
+    tox_ini.write_text("[tox]\nenv_list=py")
 
     with pytest.raises(RuntimeError, match=r"missing tox environment\(s\) to pin missing_1, missing_2"):
         format_tox_ini(tox_ini, ToxIniFmtNamespace(pin_toxenvs=["missing_1", "missing_2"]))
 
 
 def test_pin(tox_ini: Path) -> None:
     tox_ini.write_text(
-        "[tox]\nenvlist=py38,pkg,py,py39,pypy3,pypy,pin,extra\n"
+        "[tox]\nenv_list=py38,pkg,py,py39,pypy3,pypy,pin,extra\n"
         "[testenv:py38]\ne=f\n"
         "[testenv:pkg]\nc=d\n"
         "[testenv:py]\ng=h\n"
@@ -93,7 +95,9 @@ def test_pin(tox_ini: Path) -> None:
     expected = dedent(
         """
         [tox]
-        envlist =
+        requires =
+            tox>=4.2
+        env_list =
             pin
             pkg
             py39