antsibull-nox 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

antsibull_nox/lint_config.py

@@ -0,0 +1,113 @@
+# Author: Felix Fontein <felix@fontein.de>
+# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or
+# https://www.gnu.org/licenses/gpl-3.0.txt)
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025, Ansible Project
+
+"""Lint antsibull-nox config."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from .config import lint_config_toml
+
+NOXFILE_PY = "noxfile.py"
+
+
+def _is_antsibull_nox_module(module_name: str) -> bool:
+    return module_name == "antsibull_nox" or module_name.startswith("antsibull_nox.")
+
+
+class _Walker:
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.imports: dict[str, str] = {}
+        self.has_config_load = False
+
+    @staticmethod
+    def _get_name(what: ast.expr) -> str | None:
+        if isinstance(what, ast.Name):
+            return what.id
+        if isinstance(what, ast.Attribute):
+            v = _Walker._get_name(what.value)
+            return None if v is None else f"{v}.{what.attr}"
+        return None
+
+    def _check_expression(self, expression: ast.expr) -> None:
+        if isinstance(expression, ast.Call):
+            func = _Walker._get_name(expression.func)
+            if func is not None:
+                func = self.imports.get(func, func)
+                if "." in func:
+                    module, module_func = func.rsplit(".", 1)
+                    if module in self.imports:
+                        func = f"{self.imports[module]}.{module_func}"
+                if func == "antsibull_nox.load_antsibull_nox_toml":
+                    self.has_config_load = True
+
+    def _walk(self, statements: list[ast.stmt]) -> None:
+        for statement in statements:
+            # Handle imports
+            if isinstance(statement, ast.Import):
+                for alias in statement.names:
+                    if _is_antsibull_nox_module(alias.name):
+                        self.imports[alias.asname or alias.name] = alias.name
+            if isinstance(statement, ast.ImportFrom):
+                if statement.level == 0 and _is_antsibull_nox_module(
+                    statement.module or ""
+                ):
+                    for alias in statement.names:
+                        self.imports[alias.asname or alias.name] = (
+                            f"{statement.module}.{alias.name}"
+                        )
+            # Handle try block
+            if isinstance(statement, ast.Try):
+                self._walk(statement.body)
+            # Handle expressions
+            if isinstance(statement, ast.Expr):
+                self._check_expression(statement.value)
+
+    def walk(self, module: ast.Module) -> list[str]:
+        """
+        Walk the noxfile's module and return a list of errors.
+        """
+        self._walk(module.body)
+        errors = []
+        if not self.imports:
+            errors.append(f"{self.path}: Found no antsibull_nox import")
+        if not self.has_config_load:
+            errors.append(
+                f"{self.path}: Found no call to antsibull_nox.load_antsibull_nox_toml()"
+            )
+        return errors
+
+
+def lint_noxfile() -> list[str]:
+    """
+    Do basic validation for noxfile.py. Return a list of errors.
+    """
+    path = Path(NOXFILE_PY)
+    try:
+        with open(path, "rt", encoding="utf-8") as f:
+            root = ast.parse(f.read(), filename=path)
+    except FileNotFoundError:
+        return [f"{path}: File does not exist"]
+    except Exception as exc:  # pylint: disable=broad-exception-caught
+        return [f"{path}:Error while parsing Python code: {exc}"]
+
+    walker = _Walker(path)
+    return walker.walk(root)
+
+
+def lint_config() -> list[str]:
+    """
+    Lint antsibull-nox config file.
+    """
+    errors = lint_config_toml()
+    errors.extend(lint_noxfile())
+    return sorted(errors)
+
+
+__all__ = ["lint_config"]

antsibull_nox/sessions/__init__.py

@@ -0,0 +1,70 @@
+# Author: Felix Fontein <felix@fontein.de>
+# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or
+# https://www.gnu.org/licenses/gpl-3.0.txt)
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025, Ansible Project
+
+"""
+Create nox sessions.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+import nox
+
+from .collections import (  # Re-export for usage in noxfiles
+    CollectionSetup,
+    prepare_collections,
+)
+from .utils import get_registered_sessions
+
+
+def add_matrix_generator() -> None:
+    """
+    Add a session that generates matrixes for CI systems.
+    """
+
+    def matrix_generator(
+        session: nox.Session,  # pylint: disable=unused-argument
+    ) -> None:
+        registered_sessions = get_registered_sessions()
+
+        json_output = os.environ.get("ANTSIBULL_NOX_MATRIX_JSON")
+        if json_output:
+            print(f"Writing JSON output to {json_output}...")
+            with open(json_output, "wt", encoding="utf-8") as f:
+                f.write(json.dumps(registered_sessions))
+
+        github_output = os.environ.get("GITHUB_OUTPUT")
+        if github_output:
+            print(f"Writing GitHub output to {github_output}...")
+            with open(github_output, "at", encoding="utf-8") as f:
+                for name, sessions in registered_sessions.items():
+                    f.write(f"{name}={json.dumps(sessions)}\n")
+
+        for name, sessions in sorted(registered_sessions.items()):
+            print(f"{name} ({len(sessions)}):")
+            for session_data in sessions:
+                data = session_data.copy()
+                session_name = data.pop("name")
+                print(f"  {session_name}: {data}")
+
+        sys.stdout.flush()
+
+    matrix_generator.__doc__ = "Generate matrix for CI systems."
+    nox.session(
+        name="matrix-generator",
+        python=False,
+        default=False,
+    )(matrix_generator)
+
+
+__all__ = [
+    "CollectionSetup",
+    "add_matrix_generator",
+    "prepare_collections",
+]

antsibull_nox/sessions/ansible_lint.py

@@ -0,0 +1,58 @@
+# Author: Felix Fontein <felix@fontein.de>
+# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or
+# https://www.gnu.org/licenses/gpl-3.0.txt)
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-FileCopyrightText: 2025, Ansible Project
+
+"""
+Create nox ansible-lint session.
+"""
+
+from __future__ import annotations
+
+import nox
+
+from .collections import prepare_collections
+from .utils import install
+
+
+def add_ansible_lint(
+    *,
+    make_ansible_lint_default: bool = True,
+    ansible_lint_package: str = "ansible-lint",
+    strict: bool = False,
+) -> None:
+    """
+    Add a session that runs ansible-lint.
+    """
+
+    def compose_dependencies() -> list[str]:
+        return [ansible_lint_package]
+
+    def ansible_lint(session: nox.Session) -> None:
+        install(session, *compose_dependencies())
+        prepared_collections = prepare_collections(
+            session,
+            install_in_site_packages=False,
+            install_out_of_tree=True,
+            extra_deps_files=["tests/integration/requirements.yml"],
+        )
+        if not prepared_collections:
+            session.warn("Skipping ansible-lint...")
+            return
+        env = {"ANSIBLE_COLLECTIONS_PATH": f"{prepared_collections.current_place}"}
+        command = ["ansible-lint", "--offline"]
+        if strict:
+            command.append("--strict")
+        session.run(*command, env=env)
+
+    ansible_lint.__doc__ = "Run ansible-lint."
+    nox.session(
+        name="ansible-lint",
+        default=make_ansible_lint_default,
+    )(ansible_lint)
+
+
+__all__ = [
+    "add_ansible_lint",
+]