cli/analyzers.py

# Copyright 2023 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Shared helpers for cros analyzer commands (fix, lint, format)."""

from abc import ABC
import logging
import os
from pathlib import Path
from typing import List

from chromite.cli import command
from chromite.lib import commandline
from chromite.lib import git


def GetFilesFromCommit(commit: str) -> List[str]:
    """Returns files changed in the provided git `commit` as absolute paths."""
    repo_root_path = git.FindGitTopLevel(None)
    files_in_repo = git.RunGit(
        repo_root_path,
        ["diff-tree", "--no-commit-id", "--name-only", "-r", commit],
    ).stdout.splitlines()
    return [os.path.join(repo_root_path, p) for p in files_in_repo]


def HasUncommittedChanges(files: List[str]) -> bool:
    """Returns whether there are uncommitted changes on any of the `files`.

    `files` can be absolute or relative to the current working directory. If a
    file is passed that is outside the git repository corresponding to the
    current working directory, an exception will be thrown.
    """
    working_status = git.RunGit(
        None, ["status", "--porcelain=v1", *files]
    ).stdout.splitlines()
    if working_status:
        logging.warning("%s", "\n".join(working_status))
    return bool(working_status)


class AnalyzerCommand(ABC, command.CliCommand):
    """Shared argument parsing for cros analyzers (fix, lint, format)."""

    use_dryrun_options = True
    # Override base class property to use path filter options.
    use_filter_options = True

    @classmethod
    def AddParser(cls, parser):
        super().AddParser(parser)
        parser.add_argument(
            "--check",
            dest="dryrun",
            action="store_true",
            help="Display files with errors & exit non-zero",
        )
        parser.add_argument(
            "--diff",
            action="store_true",
            help="Display diff instead of fixed content",
        )
        parser.add_argument(
            "--stdout",
            dest="inplace",
            action="store_false",
            help="Write to stdout",
        )
        parser.add_argument(
            "-i",
            "--inplace",
            default=True,
            action="store_true",
            help="Fix files inplace (default)",
        )
        parser.add_argument(
            "--commit",
            type=str,
            help=(
                "Use files from git commit instead of on disk. If no files are"
                " provided, the list will be obtained from git diff-tree."
            ),
        )
        parser.add_argument(
            "--head",
            dest="commit",
            action="store_const",
            const="HEAD",
            help="Alias for --commit HEAD.",
        )
        parser.add_argument(
            "files",
            nargs="*",
            type=Path,
            help=(
                "Files to fix. Directories will be expanded, and if in a git"
                " repository, the .gitignore will be respected."
            ),
        )

    @classmethod
    def ProcessOptions(
        cls,
        parser: commandline.ArgumentParser,
        options: commandline.ArgumentNamespace,
    ) -> None:
        """Validate & post-process options before freezing."""
        if options.commit and not options.files:
            options.files = GetFilesFromCommit(options.commit)

        if options.commit and options.inplace:
            # If a commit is provided, bail when using inplace if any of the
            # files have uncommitted changes. This is because the input to the
            # analyzer will not consider any working state changes, so they will
            # likely be lost. In future this may be supported by attempting to
            # stash and rebase changes. See also b/290714959.
            if HasUncommittedChanges(options.files):
                parser.error("In-place may clobber uncommitted changes.")

        if not options.files:
            # Running with no arguments is allowed to make the repo upload hook
            # simple, but print a warning so that if someone runs this manually
            # they are aware that nothing was changed.
            logging.warning("No files provided.  Doing nothing.")