Add option -o (or --output-format) to customize output format

Author: flashcode

CHANGELOG.md

@@ -17,6 +17,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
 
 ### Added
 
+- Add option `-o` (or `--output-format`) to customize output format
 - Add official pre-commit hook
 
 ## Version 4.1.0 (2024-10-23)

README.md

@@ -65,6 +65,7 @@ Options:
 - `-W`, `--no-whitespace-eol`: do not check whitespace at end of lines inside strings
 - `-e`, `--extract`: display all translations and exit (all checks except compilation are disabled in this mode)
 - `-i`, `--ignore-errors`: display but ignore errors (always return 0)
+- `-o`, `--output-format`: output format
 - `-q`, `--quiet`: quiet mode: only display number of errors
 - `-v`, `--version`: display version and exit
 

src/msgcheck/msgcheck.py

@@ -40,7 +40,7 @@
 import shlex
 import sys
 
-from msgcheck.po import PoCheck, PoReport
+from msgcheck.po import PoCheck, PoFileReport
 
 
 def msgcheck_parser() -> argparse.ArgumentParser:
@@ -138,6 +138,13 @@ def msgcheck_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="display but ignore errors (always return 0)",
     )
+    parser.add_argument(
+        "-o",
+        "--output-format",
+        choices=["full", "oneline"],
+        default="full",
+        help="output format: full = complete output, oneline = one line output",
+    )
     parser.add_argument(
         "-q",
         "--quiet",
@@ -167,7 +174,7 @@ def msgcheck_args(parser: argparse.ArgumentParser) -> argparse.Namespace:
     return parser.parse_args(shlex.split(os.getenv("MSGCHECK_OPTIONS") or "") + sys.argv[1:])
 
 
-def msgcheck_check_files(args: argparse.Namespace) -> list[tuple[str, list[PoReport]]]:
+def msgcheck_check_files(args: argparse.Namespace) -> list[PoFileReport]:
     """Check files."""
     # create checker and set boolean options
     po_check = PoCheck()
@@ -195,30 +202,27 @@ def msgcheck_check_files(args: argparse.Namespace) -> list[tuple[str, list[PoRep
     return result
 
 
-def msgcheck_display_errors(
-    args: argparse.Namespace,
-    result: list[tuple[str, list[PoReport]]],
-) -> tuple[int, int, int]:
+def msgcheck_display_errors(args: argparse.Namespace, result: list[PoFileReport]) -> tuple[int, int, int]:
     """Display error messages."""
     files_ok, files_with_errors, total_errors = 0, 0, 0
-    for _, reports in result:
-        if not reports:
+    for report in result:
+        if not report:
             files_ok += 1
             continue
         files_with_errors += 1
-        total_errors += len(reports)
+        total_errors += len(report)
         if not args.quiet:
             if args.only_misspelled:
                 words = []
-                for report in reports:
-                    words.extend(report.get_misspelled_words())
+                for error in report:
+                    words.extend(error.get_misspelled_words())
                 print("\n".join(sorted(set(words), key=lambda s: s.lower())))
             else:
-                print("\n".join([str(report) for report in reports]))
+                print("\n".join([error.to_string(fmt=args.output_format) for error in report]))
     return files_ok, files_with_errors, total_errors
 
 
-def msgcheck_display_result(args: argparse.Namespace, result: list[tuple[str, list[PoReport]]]) -> int:
+def msgcheck_display_result(args: argparse.Namespace, result: list[PoFileReport]) -> int:
     """Display result and return the number of files with errors."""
     # display errors
     files_ok, files_with_errors, total_errors = msgcheck_display_errors(args, result)
@@ -229,19 +233,21 @@ def msgcheck_display_result(args: argparse.Namespace, result: list[tuple[str, li
         sys.exit(0)
 
     # display files with number of errors
-    if total_errors > 0 and not args.quiet:
-        print("=" * 70)
-    for filename, reports in result:
-        errors = len(reports)
-        if errors == 0:
-            print(f"{filename}: OK")
-        else:
-            str_result = "almost good!" if errors <= 10 else "uh oh... try again!"  # noqa: PLR2004
-            print(f"{filename}: {errors} errors ({str_result})")
+    if args.output_format == "full":
+        if total_errors > 0 and not args.quiet:
+            print("=" * 70)
+        for report in result:
+            errors = len(report)
+            if errors == 0:
+                print(f"{report.filename}: OK")
+            else:
+                str_result = "almost good!" if errors <= 10 else "uh oh... try again!"  # noqa: PLR2004
+                print(f"{report.filename}: {errors} errors ({str_result})")
 
     # display total (if many files processed)
-    str_errors = f", {files_with_errors} files with {total_errors} errors" if files_with_errors > 0 else ""
-    print(f"TOTAL: {files_ok} files OK{str_errors}")
+    if args.output_format == "full":
+        str_errors = f", {files_with_errors} files with {total_errors} errors" if files_with_errors > 0 else ""
+        print(f"TOTAL: {files_ok} files OK{str_errors}")
 
     return files_with_errors
 

src/msgcheck/po.py

@@ -72,18 +72,24 @@ def __init__(  # noqa: PLR0913
         self.mstr = mstr
         self.fuzzy = fuzzy
 
-    def __repr__(self) -> str:
+    def to_string(self, fmt: str = "full") -> str:  # noqa: PLR0911
         """Return PO report as string."""
         if self.idmsg == "extract":
             if isinstance(self.message, list):
                 return ", ".join(self.message) + "\n---"
             return self.message + "\n---"
         if self.idmsg == "compile":
+            if fmt == "oneline":
+                if isinstance(self.message, list):
+                    return self.message[0]
+                return self.message.split("\n")[0]
             return f"{'=' * 70}\n{self.message}"
         is_list = isinstance(self.message, list)
         count = f"({len(self.message)})" if is_list else ""
         str_fuzzy = "(fuzzy) " if self.fuzzy else ""
         str_msg = ", ".join(self.message) if is_list else self.message
+        if fmt == "oneline":
+            return f"{self.filename}:{self.line}: [{self.idmsg}{count}] {str_fuzzy}{str_msg}"
         msg = f"{'=' * 70}\n{self.filename}:{self.line}: [{self.idmsg}{count}] {str_fuzzy}{str_msg}"
         if self.mid:
             msg += "\n---\n" + self.mid
@@ -96,6 +102,14 @@ def get_misspelled_words(self) -> list[str]:
         return self.message if isinstance(self.message, list) else []
 
 
+class PoFileReport(list):
+    """A file report."""
+
+    def __init__(self, filename: str = "-") -> None:
+        """Initialize PO file report."""
+        self.filename = filename
+
+
 class PoMessage:
     """A message from a gettext file.
 
@@ -615,40 +629,42 @@ def check_pofile(self, po_file: PoFile) -> list[PoReport]:
 
         return reports
 
-    def check_file(self, filename: str) -> list[PoReport]:
-        """Check compilation and translations in a PO file.
-
-        Return a list of tuples: (filename, [PoReport, PoReport, ...]).
-        """
+    def check_file(self, filename: str) -> PoFileReport :
+        """Check compilation and translations in a PO file."""
         po_file = PoFile(filename)
+        report = PoFileReport(po_file.filename)
         # read the file
         try:
             po_file.read()
         except OSError as exc:
-            return [PoReport(str(exc), "read", po_file.filename)]
+            report.append(PoReport(str(exc), "read", po_file.filename))
+            return report
         # compile the file (except if disabled)
         compile_rc = 0
         if self.checks["compile"]:
             compile_output, compile_rc = po_file.compile()
         if compile_rc != 0:
             # compilation failed
-            return [PoReport(compile_output, "compile", po_file.filename)]
+            report.append(PoReport(compile_output, "compile", po_file.filename))
+            return report
         # compilation OK
-        return self.check_pofile(po_file)
+        report.extend(self.check_pofile(po_file))
+        return report
 
-    def check_files(self, files: list[str]) -> list[tuple[str, list[PoReport]]]:
+    def check_files(self, files: list[str]) -> list[PoFileReport]:
         """Check compilation and translations in PO files.
 
         Return a list of tuples: (filename, [PoReport, PoReport, ...]).
         """
-        result: list[tuple[str, list[PoReport]]] = []
+        result: list[PoFileReport] = []
         for path in files:
             if Path(path).is_dir():
                 for root, _, filenames in os.walk(path):
-                    for filename in filenames:
-                        if filename.endswith(".po"):
-                            path_po = Path(root) / filename
-                            result.append((str(path_po), self.check_file(str(path_po))))
+                    result.extend([
+                        self.check_file(str(Path(root) / filename))
+                        for filename in filenames
+                        if filename.endswith(".po")
+                    ])
             else:
-                result.append((path, self.check_file(path)))
+                result.append(self.check_file(path))
         return result

tests/test_msgcheck.py

@@ -62,38 +62,38 @@ def test_extract() -> None:
     po_check.set_check("extract", True)
     result = po_check.check_files([local_path("fr.po")])
     assert len(result) == 1
-    assert "fr.po" in result[0][0]
-    assert len(result[0][1]) == 3
+    assert "fr.po" in result[0].filename
+    assert len(result[0]) == 3
 
-    report = result[0][1][0]
+    report = result[0][0]
     assert report.message == "Ceci est un test.\n"
     assert report.idmsg == "extract"
     assert report.filename == "-"
     assert report.line == 0
     assert report.mid == ""
     assert report.mstr == ""
     assert report.fuzzy is False
-    assert str(report) == "Ceci est un test.\n\n---"
+    assert report.to_string() == "Ceci est un test.\n\n---"
 
-    report = result[0][1][1]
+    report = result[0][1]
     assert report.message == "Test sur deux lignes.\nLigne 2."
     assert report.idmsg == "extract"
     assert report.filename == "-"
     assert report.line == 0
     assert report.mid == ""
     assert report.mstr == ""
     assert report.fuzzy is False
-    assert str(report) == "Test sur deux lignes.\nLigne 2.\n---"
+    assert report.to_string() == "Test sur deux lignes.\nLigne 2.\n---"
 
-    report = result[0][1][2]
+    report = result[0][2]
     assert report.message == " erreur : %s"  # noqa: RUF001
     assert report.idmsg == "extract"
     assert report.filename == "-"
     assert report.line == 0
     assert report.mid == ""
     assert report.mstr == ""
     assert report.fuzzy is False
-    assert str(report) == " erreur : %s\n---"  # noqa: RUF001
+    assert report.to_string() == " erreur : %s\n---"  # noqa: RUF001
 
 
 def test_checks() -> None:
@@ -105,24 +105,24 @@ def test_checks() -> None:
     assert len(result) == 2
 
     # first file has no errors
-    assert not result[0][1]
+    assert not result[0]
 
     # second file has 10 errors
-    assert len(result[1][1]) == 9
+    assert len(result[1]) == 9
 
     # check first error
-    report = result[1][1][0]
+    report = result[1][0]
     assert report.message == "number of lines: 2 in string, 1 in translation"
     assert report.idmsg == "lines"
     assert "fr_errors.po" in report.filename
     assert report.line == 44
     assert report.mid == "Test 1 on two lines.\nLine 2."
     assert report.mstr == "Test 1 sur deux lignes."
     assert report.fuzzy is False
-    assert "fr_errors.po:44: [lines] number of lines: 2 in string, 1 in translation" in str(report)
+    assert "fr_errors.po:44: [lines] number of lines: 2 in string, 1 in translation" in report.to_string()
 
     # check last error
-    report = result[1][1][8]
+    report = result[1][8]
     expected = "different whitespace at end of a line: 1 in string, 0 in translation"
     assert report.message == expected
     assert report.idmsg == "whitespace_eol"
@@ -133,8 +133,8 @@ def test_checks() -> None:
     assert report.fuzzy is False
 
     # check number of errors by type
-    errors = {}
-    for report in result[1][1]:
+    errors: dict[str, int] = {}
+    for report in result[1]:
         errors[report.idmsg] = errors.get(report.idmsg, 0) + 1
     assert errors["lines"] == 2
     assert errors["punct"] == 1
@@ -152,7 +152,7 @@ def test_checks_fuzzy() -> None:
     assert len(result) == 1
 
     # the file has 11 errors (with the fuzzy string)
-    assert len(result[0][1]) == 10
+    assert len(result[0]) == 10
 
 
 def test_checks_noqa() -> None:
@@ -165,7 +165,7 @@ def test_checks_noqa() -> None:
     assert len(result) == 1
 
     # the file has 10 errors (including `noqa`-commented lines)
-    assert len(result[0][1]) == 10
+    assert len(result[0]) == 10
 
 
 def test_replace_fmt_c() -> None:
@@ -238,7 +238,7 @@ def test_spelling_id() -> None:
     assert len(result) == 1
 
     # the file has 2 spelling errors: "Thsi" and "errro"
-    report = result[0][1]
+    report = result[0]
     assert len(report) == 3
     for i, word in enumerate(("Thsi", "testtwo", "errro")):
         assert report[i].idmsg == "spelling-id"
@@ -262,7 +262,7 @@ def test_spelling_id_multilpe_pwl() -> None:
     assert len(result) == 1
 
     # the file has 2 spelling errors: "Thsi" and "errro"
-    report = result[0][1]
+    report = result[0]
     assert len(report) == 2
     for i, word in enumerate(("Thsi", "errro")):
         assert report[i].idmsg == "spelling-id"
@@ -283,7 +283,7 @@ def test_spelling_str() -> None:
     assert len(result) == 2
 
     # first file has 3 spelling errors: "CecX", "aabbcc" and "xxyyzz"
-    report = result[0][1]
+    report = result[0]
     assert len(report) == 4
     for i, word in enumerate(("testtwo", "CecX", "aabbcc", "xxyyzz")):
         assert report[i].idmsg == "spelling-str"
@@ -293,7 +293,7 @@ def test_spelling_str() -> None:
         assert report[i].get_misspelled_words() == [word]
 
     # second file has 1 error: dict/language "xyz" not found
-    report = result[1][1]
+    report = result[1]
     assert len(report) == 1
     assert report[0].idmsg == "dict"
 
@@ -312,7 +312,7 @@ def test_spelling_str_multiple_pwl() -> None:
     assert len(result) == 2
 
     # first file has 3 spelling errors: "CecX", "aabbcc" and "xxyyzz"
-    report = result[0][1]
+    report = result[0]
     assert len(report) == 3
     for i, word in enumerate(("CecX", "aabbcc", "xxyyzz")):
         assert report[i].idmsg == "spelling-str"
@@ -322,7 +322,7 @@ def test_spelling_str_multiple_pwl() -> None:
         assert report[i].get_misspelled_words() == [word]
 
     # second file has 1 error: dict/language "xyz" not found
-    report = result[1][1]
+    report = result[1]
     assert len(report) == 1
     assert report[0].idmsg == "dict"
 
@@ -416,4 +416,4 @@ def test_invalid_utf8() -> None:
     assert len(result) == 1
 
     # the file has no errors
-    assert len(result[0][1]) == 0
+    assert len(result[0]) == 0