forceupdate 0.1.0__py3-none-any.whl

forceupdate/cli.py

@@ -0,0 +1,309 @@
+"""Ligne de commande : ``forceupdate ui``, ``scan`` et ``update``.
+
+Pas de logique métier ici : chaque commande appelle le moteur, et les rapports (``report/``)
+mettent le résultat en forme. Codes de retour : 0 rien à signaler, 1 seuil ``--fail-on``
+atteint, 2 erreur.
+
+Le JSON et le Markdown sortent toujours en UTF-8, sur la sortie standard comme dans un fichier.
+Sous Windows, une sortie redirigée serait sinon écrite dans le codage de la console (cp1252) :
+la sortie standard redirigée est donc repassée en UTF-8 (``_utf8_stdout``).
+"""
+
+import enum
+import io
+import sys
+from pathlib import Path
+from typing import Annotated, NoReturn
+
+import typer
+from rich.console import Console
+from rich.progress import BarColumn, MofNCompleteColumn, Progress, SpinnerColumn, TextColumn
+
+from forceupdate import __version__, checks, engine
+from forceupdate.checks import FailOn
+from forceupdate.models import Ecosystem, Event, EventKind, Gap, ScanOptions
+from forceupdate.report import json as json_report
+from forceupdate.report import markdown, terminal
+from forceupdate.sources.base import SourceError
+from forceupdate.sources.local import LocalSource
+from forceupdate.update import planner
+
+EXIT_FAIL_ON = 1
+EXIT_ERROR = 2
+
+FILE_WIDTH = 120
+"""Largeur du rapport terminal écrit dans un fichier (``--output``)."""
+
+app = typer.Typer(
+    name="forceupdate",
+    help="Trouve les dépendances à mettre à jour, et fait les mises à jour.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+PathArgument = Annotated[
+    Path,
+    typer.Argument(help="Dossier ou fichier à traiter (par défaut, le dossier courant)."),
+]
+
+
+class OutputFormat(enum.StrEnum):
+    TERMINAL = "terminal"
+    JSON = "json"
+    MD = "md"
+
+
+def _print_version(value: bool) -> None:
+    if value:
+        typer.echo(f"forceupdate {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            callback=_print_version,
+            is_eager=True,
+            help="Affiche la version et quitte.",
+        ),
+    ] = False,
+) -> None:
+    """Trouve les dépendances à mettre à jour, et fait les mises à jour."""
+
+
+def _fail(command: str, message: str) -> NoReturn:
+    """Affiche l'erreur sur stderr, et sort avec le code d'erreur."""
+    typer.echo(f"forceupdate {command} : {message}", err=True)
+    raise typer.Exit(code=EXIT_ERROR)
+
+
+def _not_available(command: str) -> NoReturn:
+    """Commande prévue au plan mais pas encore écrite : le dire, et sortir en erreur."""
+    _fail(command, "pas encore disponible.")
+
+
+@app.command()
+def ui() -> None:
+    """Ouvre l'interface web dans le navigateur."""
+    _not_available("ui")
+
+
+@app.command()
+def scan(
+    path: PathArgument = Path("."),
+    output_format: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Forme du rapport : terminal, json ou md."),
+    ] = OutputFormat.TERMINAL,
+    output: Annotated[
+        Path | None,
+        typer.Option(
+            "--output",
+            "-o",
+            dir_okay=False,
+            help="Écrit le rapport dans ce fichier (UTF-8) au lieu de la sortie standard.",
+        ),
+    ] = None,
+    dev: Annotated[
+        bool,
+        typer.Option(
+            "--dev/--no-dev", help="Vérifie aussi les dépendances de développement (par défaut)."
+        ),
+    ] = True,
+    transitive: Annotated[
+        bool,
+        typer.Option(
+            "--transitive",
+            help=(
+                "Cherche aussi les versions plus récentes, retirées ou dépréciées des "
+                "dépendances indirectes (leurs failles sont toujours cherchées)."
+            ),
+        ),
+    ] = False,
+    offline: Annotated[
+        bool,
+        typer.Option(
+            "--offline",
+            help="N'interroge pas les registres : seulement le cache, le reste « non concluant ».",
+        ),
+    ] = False,
+    no_cache: Annotated[
+        bool,
+        typer.Option("--no-cache", help="Ne lit ni n'écrit le cache disque."),
+    ] = False,
+    fail_on: Annotated[
+        FailOn | None,
+        typer.Option(
+            "--fail-on",
+            help=(
+                "Sort avec le code 1 si un constat atteint ce seuil : vuln (une faille), major "
+                "(faille, fin de vie, retirée, dépréciée ou majeure), any (tout ce qui est à "
+                "mettre à jour)."
+            ),
+        ),
+    ] = None,
+) -> None:
+    """Analyse un dossier ou un fichier : langages, dépendances, ce qui est à mettre à jour."""
+    try:
+        source = LocalSource(path)
+    except SourceError as err:
+        _fail("scan", f"{err}.")
+    options = ScanOptions(dev=dev, transitive=transitive, offline=offline, cache=not no_cache)
+    with _ProgressBar(Console(stderr=True)) as progress:
+        report = engine.scan(source, options, on_event=progress)
+
+    if output_format is OutputFormat.JSON:
+        text = json_report.render(report)
+    elif output_format is OutputFormat.MD:
+        text = markdown.render(report)
+    elif output is not None:
+        buffer = io.StringIO()
+        terminal.render(report, Console(file=buffer, width=FILE_WIDTH, color_system=None))
+        text = buffer.getvalue()
+    else:
+        _utf8_stdout()
+        terminal.render(report, Console(highlight=False))
+        text = None
+
+    if text is not None:
+        if output is None:
+            _utf8_stdout()
+            sys.stdout.write(text)
+            sys.stdout.flush()
+        else:
+            try:
+                output.write_text(text, encoding="utf-8", newline="\n")
+            except OSError as err:
+                _fail("scan", f"impossible d'écrire « {output} » : {err.strerror or err}.")
+
+    if fail_on is not None and checks.fails(report.findings, fail_on):
+        raise typer.Exit(code=EXIT_FAIL_ON)
+
+
+@app.command()
+def update(
+    path: PathArgument = Path("."),
+    level: Annotated[
+        Gap,
+        typer.Option(
+            "--level",
+            case_sensitive=False,
+            help=(
+                "Écart le plus grand choisi : patch (correctifs), minor (et mineures, par "
+                "défaut), major (et majeures, qui peuvent demander d'adapter le code)."
+            ),
+        ),
+    ] = Gap.MINOR,
+    security_only: Annotated[
+        bool,
+        typer.Option("--security-only", help="Choisit seulement les corrections de failles."),
+    ] = False,
+    include: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--include",
+            help="Ne choisit que les paquets dont le nom correspond (« * » permis ; répétable).",
+        ),
+    ] = None,
+    exclude: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--exclude",
+            help="Écarte les paquets dont le nom correspond (« * » permis ; répétable).",
+        ),
+    ] = None,
+    ecosystem: Annotated[
+        list[Ecosystem] | None,
+        typer.Option(
+            "--ecosystem",
+            case_sensitive=False,
+            help="Ne choisit que les paquets de cet écosystème (répétable).",
+        ),
+    ] = None,
+    dev: Annotated[
+        bool,
+        typer.Option(
+            "--dev/--no-dev",
+            help="Met à jour aussi les dépendances de développement (par défaut).",
+        ),
+    ] = True,
+    offline: Annotated[
+        bool,
+        typer.Option(
+            "--offline",
+            help="N'interroge pas les registres : seulement le cache, le reste « non concluant ».",
+        ),
+    ] = False,
+    no_cache: Annotated[
+        bool,
+        typer.Option("--no-cache", help="Ne lit ni n'écrit le cache disque."),
+    ] = False,
+) -> None:
+    """Met à jour les dépendances d'un dossier ou d'un fichier.
+
+    Pour l'instant, montre les mises à jour choisies, sans rien écrire.
+    """
+    try:
+        source = LocalSource(path)
+    except SourceError as err:
+        _fail("update", f"{err}.")
+    options = ScanOptions(dev=dev, offline=offline, cache=not no_cache)
+    with _ProgressBar(Console(stderr=True)) as progress:
+        report = engine.scan(source, options, on_event=progress)
+    rules = planner.Rules(
+        level=level,
+        security_only=security_only,
+        include=tuple(include or ()),
+        exclude=tuple(exclude or ()),
+        ecosystems=frozenset(ecosystem or ()),
+    )
+    _utf8_stdout()
+    terminal.render_plan(report, planner.select(report, rules), Console(highlight=False), rules)
+
+
+def _utf8_stdout() -> None:
+    """Passe la sortie standard en UTF-8 si elle est redirigée (un fichier, un tube). Dans une
+    console, Python écrit déjà de l'Unicode, quel que soit le codage de la console."""
+    stdout = sys.stdout
+    if stdout.isatty() or not isinstance(stdout, io.TextIOWrapper):
+        return
+    if stdout.encoding.lower().replace("-", "") != "utf8":
+        stdout.reconfigure(encoding="utf-8")
+
+
+class _ProgressBar:
+    """Affiche les événements du moteur en barre de progression, sur la sortie d'erreur, et
+    seulement dans une console : rien ne s'écrit dans une sortie redirigée."""
+
+    def __init__(self, console: Console) -> None:
+        self._progress = Progress(
+            SpinnerColumn(),
+            TextColumn("{task.description}"),
+            BarColumn(),
+            MofNCompleteColumn(),
+            TextColumn("{task.fields[name]}", style="dim"),
+            console=console,
+            transient=True,
+            disable=not console.is_terminal,
+        )
+        self._task = self._progress.add_task("Lecture des projets", total=None, name="")
+
+    def __enter__(self) -> "_ProgressBar":
+        self._progress.start()
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self._progress.stop()
+
+    def __call__(self, event: Event) -> None:
+        if event.kind is EventKind.CHECKING:
+            self._progress.update(
+                self._task, description="Vérification des paquets", total=event.total, completed=0
+            )
+        elif event.kind is EventKind.PACKAGE_CHECKED:
+            self._progress.update(self._task, completed=event.done, name=event.name or "")
+        elif event.kind is EventKind.VULNERABILITIES_CHECKED:
+            self._progress.update(self._task, completed=event.done, name="failles (OSV)")

forceupdate/detect/__init__.py

@@ -0,0 +1,5 @@
+"""Ce que contient une source : ses langages, et ses projets (manifestes et lockfiles).
+
+Tout se fait sur des chemins et des tailles, sans lire les fichiers : ça marche
+pareil sur un dossier local et sur l'arborescence d'un dépôt distant (E17).
+"""

forceupdate/detect/languages.py

@@ -0,0 +1,266 @@
+"""Les langages d'une source, et leur poids en octets, comme GitHub Linguist.
+
+Le détecteur travaille sur une liste de ``(chemin, taille)``, sans lire les
+fichiers : il sert tel quel à un dossier local et à l'arborescence d'un dépôt sur
+une forge (E17).
+
+Comme Linguist :
+
+- le langage d'un fichier vient de son extension, ou de son nom (``Dockerfile``) ;
+- seuls comptent les langages de programmation et de balisage. JSON, YAML, TOML ou
+  Markdown sont des données ou de la prose : ils ne comptent pas ;
+- les fichiers vendorisés (``vendor/``, ``*.min.js``), générés (``*.pb.go``) et la
+  documentation (``docs/``) sont écartés.
+
+Linguist lit aussi le contenu des fichiers et ``.gitattributes`` pour lever les
+ambiguïtés. Ici on s'en tient au chemin : un ``.h`` va au C, ou au C++ (à
+l'Objective-C) quand la source n'a pas de C.
+"""
+
+import re
+from collections import Counter
+from collections.abc import Iterable
+
+from forceupdate.models import Ecosystem, Language
+
+_EXTENSIONS: dict[str, str | None] = {
+    ".py": "Python",
+    ".pyw": "Python",
+    ".pyi": "Python",
+    ".pyx": "Cython",
+    ".ipynb": "Jupyter Notebook",
+    ".js": "JavaScript",
+    ".mjs": "JavaScript",
+    ".cjs": "JavaScript",
+    ".jsx": "JavaScript",
+    ".ts": "TypeScript",
+    ".mts": "TypeScript",
+    ".cts": "TypeScript",
+    ".tsx": "TypeScript",
+    ".coffee": "CoffeeScript",
+    ".vue": "Vue",
+    ".svelte": "Svelte",
+    ".astro": "Astro",
+    ".html": "HTML",
+    ".htm": "HTML",
+    ".xhtml": "HTML",
+    ".css": "CSS",
+    ".scss": "SCSS",
+    ".sass": "Sass",
+    ".less": "Less",
+    ".java": "Java",
+    ".kt": "Kotlin",
+    ".kts": "Kotlin",
+    ".gradle": None,
+    ".gradle.kts": None,
+    ".scala": "Scala",
+    ".sc": "Scala",
+    ".groovy": "Groovy",
+    ".clj": "Clojure",
+    ".cljs": "Clojure",
+    ".cljc": "Clojure",
+    ".cs": "C#",
+    ".csx": "C#",
+    ".fs": "F#",
+    ".fsx": "F#",
+    ".fsi": "F#",
+    ".vb": "Visual Basic .NET",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".c": "C",
+    ".h": "C",
+    ".cpp": "C++",
+    ".cc": "C++",
+    ".cxx": "C++",
+    ".c++": "C++",
+    ".hpp": "C++",
+    ".hh": "C++",
+    ".hxx": "C++",
+    ".h++": "C++",
+    ".ino": "C++",
+    ".cu": "Cuda",
+    ".cuh": "Cuda",
+    ".m": "Objective-C",
+    ".mm": "Objective-C++",
+    ".swift": "Swift",
+    ".rb": "Ruby",
+    ".rake": "Ruby",
+    ".gemspec": "Ruby",
+    ".php": "PHP",
+    ".phtml": "PHP",
+    ".blade.php": "Blade",
+    ".pl": "Perl",
+    ".pm": "Perl",
+    ".lua": "Lua",
+    ".r": "R",
+    ".dart": "Dart",
+    ".ex": "Elixir",
+    ".exs": "Elixir",
+    ".erl": "Erlang",
+    ".hrl": "Erlang",
+    ".hs": "Haskell",
+    ".lhs": "Haskell",
+    ".ml": "OCaml",
+    ".mli": "OCaml",
+    ".jl": "Julia",
+    ".zig": "Zig",
+    ".nim": "Nim",
+    ".elm": "Elm",
+    ".cr": "Crystal",
+    ".sol": "Solidity",
+    ".asm": "Assembly",
+    ".nasm": "Assembly",
+    ".sh": "Shell",
+    ".bash": "Shell",
+    ".zsh": "Shell",
+    ".ksh": "Shell",
+    ".ps1": "PowerShell",
+    ".psm1": "PowerShell",
+    ".psd1": "PowerShell",
+    ".bat": "Batchfile",
+    ".cmd": "Batchfile",
+    ".mk": "Makefile",
+    ".mak": "Makefile",
+    ".cmake": "CMake",
+    ".dockerfile": "Dockerfile",
+    ".containerfile": "Dockerfile",
+    ".tf": "HCL",
+    ".tfvars": "HCL",
+    ".hcl": "HCL",
+    ".nix": "Nix",
+    ".tex": "TeX",
+}
+"""Extension (en minuscules) → langage. L'extension la plus longue l'emporte :
+``.blade.php`` avant ``.php``. ``None`` : un format de données pour Linguist
+(``build.gradle``), qui ne compte pas."""
+
+_FILENAMES: dict[str, str] = {
+    "dockerfile": "Dockerfile",
+    "containerfile": "Dockerfile",
+    "makefile": "Makefile",
+    "gnumakefile": "Makefile",
+    "cmakelists.txt": "CMake",
+    "gemfile": "Ruby",
+    "rakefile": "Ruby",
+    "vagrantfile": "Ruby",
+}
+"""Nom de fichier (en minuscules) → langage, pour les fichiers sans extension parlante."""
+
+_ECOSYSTEMS: dict[str, Ecosystem] = {
+    "Python": Ecosystem.PYPI,
+    "Cython": Ecosystem.PYPI,
+    "Jupyter Notebook": Ecosystem.PYPI,
+    "JavaScript": Ecosystem.NPM,
+    "TypeScript": Ecosystem.NPM,
+    "CoffeeScript": Ecosystem.NPM,
+    "Vue": Ecosystem.NPM,
+    "Svelte": Ecosystem.NPM,
+    "Astro": Ecosystem.NPM,
+    "Rust": Ecosystem.CRATES_IO,
+    "Go": Ecosystem.GO,
+    "PHP": Ecosystem.PACKAGIST,
+    "Blade": Ecosystem.PACKAGIST,
+    "Ruby": Ecosystem.RUBYGEMS,
+    "Java": Ecosystem.MAVEN,
+    "Kotlin": Ecosystem.MAVEN,
+    "Scala": Ecosystem.MAVEN,
+    "Groovy": Ecosystem.MAVEN,
+    "Clojure": Ecosystem.MAVEN,
+    "C#": Ecosystem.NUGET,
+    "F#": Ecosystem.NUGET,
+    "Visual Basic .NET": Ecosystem.NUGET,
+}
+"""Langage → écosystème de paquets. Un langage absent n'a pas de gestionnaire de
+paquets que forceupdate sait lire (C, C++, Swift, Shell, HTML…)."""
+
+_VENDORED = re.compile(
+    r"""
+      (^|/)(node_modules|bower_components|jspm_packages|vendors?|extern(als?)?
+            |third[-_]?party|3rd[-_]?party|Pods|Carthage|Godeps/_workspace|\.yarn)/
+    | (^|/)(dist|cache|\.github|gradle/wrapper|\.mvn/wrapper)/
+    | ^(deps|dependencies|debian)/
+    | (^|/)(gradlew|gradlew\.bat|mvnw|mvnw\.cmd|configure|config\.guess|config\.sub)$
+    | [.-]min\.(js|css)$
+    | (^|/)jquery[^/]*\.js$
+    | (^|/)bootstrap[^/]*\.(js|css)$
+    """,
+    re.VERBOSE | re.IGNORECASE,
+)
+"""Code de tiers recopié dans la source : les règles de ``vendor.yml`` de Linguist
+qui se lisent sur le chemin."""
+
+_GENERATED = re.compile(
+    r"""
+      (^|/)__generated__/
+    | \.pb\.(go|cc|h)$
+    | _pb2(_grpc)?\.pyi?$
+    | \.designer\.(cs|vb)$
+    | \.(g|freezed)\.dart$
+    """,
+    re.VERBOSE | re.IGNORECASE,
+)
+"""Code produit par un outil (protobuf, concepteurs .NET, build_runner Dart) : les
+règles de ``generated.rb`` de Linguist qui se lisent sur le chemin."""
+
+_DOCUMENTATION = re.compile(
+    r"^(docs?|examples|demos?|samples?|man)/|(^|/)(documentation|javadoc|groovydoc)/",
+    re.IGNORECASE,
+)
+"""Documentation et exemples, comme ``documentation.yml`` de Linguist : ``docs/``,
+``examples/`` comptent à la racine seulement, ``documentation/`` partout."""
+
+
+def language_for(path: str) -> str | None:
+    """Le langage d'un fichier d'après son chemin POSIX ; ``None`` s'il ne compte pas."""
+    name = path.rsplit("/", 1)[-1].lower()
+    if name in _FILENAMES:
+        return _FILENAMES[name]
+    if name.startswith(("dockerfile.", "containerfile.")):
+        return "Dockerfile"
+    # L'extension la plus longue d'abord : « a.blade.php » essaie « .blade.php », puis « .php ».
+    for index, char in enumerate(name):
+        if char == "." and index > 0 and name[index:] in _EXTENSIONS:
+            return _EXTENSIONS[name[index:]]
+    return None
+
+
+def is_excluded(path: str) -> bool:
+    """Vrai si le fichier ne compte pas dans les langages : vendorisé, généré ou documentation."""
+    return bool(_VENDORED.search(path) or _GENERATED.search(path) or _DOCUMENTATION.search(path))
+
+
+def ecosystem_for_language(name: str) -> Ecosystem | None:
+    """L'écosystème de paquets d'un langage ; ``None`` s'il n'en a pas de reconnu."""
+    return _ECOSYSTEMS.get(name)
+
+
+def detect_languages(files: Iterable[tuple[str, int]]) -> list[Language]:
+    """Les langages de ``files``, une liste de ``(chemin POSIX, taille en octets)``.
+
+    Triés du plus lourd au plus léger. Un langage qui pèse 0 octet n'apparaît pas.
+    """
+    sizes: Counter[str] = Counter()
+    headers = 0
+    for path, size in files:
+        language = language_for(path)
+        if language is None or is_excluded(path):
+            continue
+        if path.lower().endswith(".h"):
+            headers += size
+        else:
+            sizes[language] += size
+    if headers:
+        sizes[_header_language(sizes)] += headers
+    return [
+        Language(name=name, bytes=size, ecosystem=ecosystem_for_language(name))
+        for name, size in sorted(sizes.items(), key=lambda item: (-item[1], item[0]))
+        if size > 0
+    ]
+
+
+def _header_language(sizes: Counter[str]) -> str:
+    """À qui vont les ``.h`` : au C s'il y en a, sinon au C++ ou à l'Objective-C."""
+    for language in ("C", "C++", "Objective-C"):
+        if sizes[language]:
+            return language
+    return "C"