Should this library provide many configurations of diff reporters?

[matthiasschaub]

We use the build-in classes GenericDiffReporter and GenericDiffReporterConfig to configure a bunch of Reporters to use external diff programs for reporting. Should this library provide these configurations (as it does for some already) or is the user expected to set these up by themselves?

I am happy to create a PR in case those should be part of the library.

For example:

from approvaltests.reporters.generic_diff_reporter import GenericDiffReporter
from approvaltests.reporters.generic_diff_reporter_config import (
    GenericDiffReporterConfig,
)


class ReportWithPyCharmLinuxFlatpak(GenericDiffReporter):
    def __init__(self):
        super().__init__(
            config=GenericDiffReporterConfig(
                name="ReportWithPyCharmLinuxFlatpak",
                path="/usr/bin/flatpak",
                extra_args=["run", "com.jetbrains.PyCharm-Community", "diff"],
            )
        )


class ReportWithPyCharmLinux(GenericDiffReporter):
    def __init__(self):
        super().__init__(
            config=GenericDiffReporterConfig(
                name="ReportWithPyCharmLinux",
                path="pycharm",
                extra_args=["diff"],
            )
        )


class ReportWithVSCodeLinux(GenericDiffReporter):
    def __init__(self):
        super().__init__(
            config=GenericDiffReporterConfig(
                name="ReportWithVSCodeLinux",
                path="/usr/bin/code",
                extra_args=["--new-window", "--wait", "--diff"],
            )
        )


class ReportWithPyCharmProfessionalMacOS(GenericDiffReporter):
    def __init__(self):
        super().__init__(
            config=GenericDiffReporterConfig(
                name="ReportWithPyCharmProfessionalMacOS",
                # Use open to block Python until diff tool is closed again
                path="/usr/bin/open",
                extra_args=[
                    # -W: Wait until the application is closed
                    "-W",
                    # -n: new instance
                    "-n",
                    # -a: application
                    "-a",
                    "/Applications/PyCharm Professional Edition.app/Contents/MacOS/pycharm",  # noqa
                    "--args",
                    "diff",
                ],
            )
        )


class ReportWithPyCharmCommunityMacOS(GenericDiffReporter):
    def __init__(self):
        super().__init__(
            config=GenericDiffReporterConfig(
                name="ReportWithPyCharmCommunityMacOS",
                # Use open to block Python until diff tool is closed again
                path="/usr/bin/open",
                extra_args=[
                    # -W: Wait until the application is closed
                    "-W",
                    # -n: New instance
                    "-n",
                    # -a: Application
                    "-a",
                    "/Applications/PyCharm CE.app/Contents/MacOS/pycharm",
                    "--args",
                    "diff",
                ],
            )
        )


class ReportWithVSCodeMacOS(GenericDiffReporter):
    def __init__(self):
        super().__init__(
            config=GenericDiffReporterConfig(
                name="ReportWithVSCodeMacOS",
                # Use open to block Python until diff tool is closed again
                path="/usr/bin/open",
                extra_args=[
                    # -W: Wait until the application is closed
                    "-W",
                    # -n: New instance
                    "-n",
                    # -a: Application
                    "-a",
                    "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",  # noqa
                    "--args",
                    "--new-window",
                    "--wait",
                    "--diff",
                ],
            )
        )

[matthiasschaub]

In case of having a bunch of diff programs be configured, it would also be nice to provide a "First Working Diff Reporter".
Something like:

class FirstWorkingDiffReporter(FirstWorkingReporter):

    def __init__(self):
        if platform.system() == "Linux":
            self.reporters = (
                ReportWithPyCharmLinux(),
                ReportWithPyCharmLinuxFlatpak(),
                ReportWithVSCodeLinux(),
            )
        elif platform.system() == "Darwin":
            self.reporters = (
                ReportWithPyCharmProfessionalMacOS(),
                ReportWithPyCharmCommunityMacOS(),
                ReportWithVSCodeMacOS(),
            )
        else:
            # TODO
            self.reporters = []
        super().__init__(*self.reporters)

[matthiasschaub]

A question in a similar vain. Should this library provide a Plotly figure reporter. Ploty figures are JSON files which are displayed by Plotly libraries. JSONs are verified, a visual representation should be reported. Hence, the need for a Plotly reporter.