Only output failing models and violated rules per default in HumanReadableFormatter

docs/index.md

@@ -12,7 +12,7 @@ encourage) good practices.
 ## Example
 
 ```
-> dbt-score lint
+> dbt-score lint --show all
 🥇 M: customers (score: 10.0)
     OK   dbt_score.rules.generic.has_description
     OK   dbt_score.rules.generic.has_owner
@@ -22,7 +22,8 @@ Score: 10.0 🥇
 
 In this example, the model `customers` scores the maximum value of `10.0` as it
 passes all the rules. It also is awarded a golden medal because of the perfect
-score.
+score. By default a passing model with or without rule violations will not be
+shown, unless we pass the `--show-all` flag.
 
 ## Philosophy
 

src/dbt_score/cli.py

@@ -94,8 +94,20 @@ def cli() -> None:
     is_flag=False,
     default=None,
 )
+@click.option(
+    "--show",
+    help="Type of output which should be shown"
+    "when using `plain` as `--format`. "
+    "`all` shows all models and all rules"
+    "`failing-models` shows failing rules of failing models"
+    "`failing-rules` shows failing rules of all models"
+    "Default behavior is to show violated rules of all models.",
+    type=click.Choice(["all", "failing-models", "failing-rules"]),
+    is_flag=False,
+    default="failing-rules",
+)
 @click.pass_context
-def lint(
+def lint(  # noqa: PLR0913, C901
     ctx: click.Context,
     format: Literal["plain", "manifest", "ascii"],
     select: tuple[str],
@@ -105,6 +117,7 @@ def lint(
     run_dbt_parse: bool,
     fail_project_under: float,
     fail_any_item_under: float,
+    show: Literal["all", "failing-models", "failing-rules"],
 ) -> None:
     """Lint dbt metadata."""
     manifest_provided = (
@@ -124,6 +137,8 @@ def lint(
         config.overload({"fail_project_under": fail_project_under})
     if fail_any_item_under:
         config.overload({"fail_any_item_under": fail_any_item_under})
+    if show:
+        config.overload({"show": show})
 
     try:
         if run_dbt_parse:

src/dbt_score/config.py

@@ -57,6 +57,7 @@ class Config:
         "inject_cwd_in_python_path",
         "fail_project_under",
         "fail_any_item_under",
+        "show",
     ]
     _rules_section: Final[str] = "rules"
     _badges_section: Final[str] = "badges"
@@ -71,6 +72,7 @@ def __init__(self) -> None:
         self.badge_config: BadgeConfig = BadgeConfig()
         self.fail_project_under: float = 5.0
         self.fail_any_item_under: float = 5.0
+        self.show: str = "failing-rules"
 
     def set_option(self, option: str, value: Any) -> None:
         """Set an option in the config."""

src/dbt_score/formatters/human_readable_formatter.py

@@ -44,26 +44,34 @@ def evaluable_evaluated(
         """Callback when an evaluable item has been evaluated."""
         if score.value < self._config.fail_any_item_under:
             self._failed_evaluables.append((evaluable, score))
+        if score.value < self._config.fail_any_item_under or self._config.show in [
+            "all",
+            "failing-rules",
+        ]:
+            resource_type = type(evaluable).__name__
+            name_formatted = f"{resource_type[0]}: {self.pretty_name(evaluable)}"
+            header = (
+                f"{score.badge} "
+                f"{self.bold(name_formatted)} (score: {score.rounded_value!s})"
+            )
 
-        resource_type = type(evaluable).__name__
-        name_formatted = f"{resource_type[0]}: {self.pretty_name(evaluable)}"
-        header = (
-            f"{score.badge} "
-            f"{self.bold(name_formatted)} (score: {score.rounded_value!s})"
-        )
-
-        print(header)
-        for rule, result in results.items():
-            if result is None:
-                print(f"{self.indent}{self.label_ok} {rule.source()}")
-            elif isinstance(result, RuleViolation):
-                print(
-                    f"{self.indent}{self.label_warning} "
-                    f"({rule.severity.name.lower()}) {rule.source()}: {result.message}"
-                )
-            else:
-                print(f"{self.indent}{self.label_error} {rule.source()}: {result!s}")
-        print()
+            print(header)
+            for rule, result in results.items():
+                if result is None:
+                    if self._config.show in ["all", "failing-models"]:
+                        print(f"{self.indent}{self.label_ok} {rule.source()}")
+                elif isinstance(result, RuleViolation):
+                    print(
+                        f"{self.indent}{self.label_warning} "
+                        f"({rule.severity.name.lower()}) {rule.source()}: "
+                        f"{result.message}"
+                    )
+                else:
+                    print(
+                        f"{self.indent}{self.label_error} {rule.source()}: "
+                        f"{result!s}"
+                    )
+            print()
 
     def project_evaluated(self, score: Score) -> None:
         """Callback when a project has been evaluated."""

tests/formatters/test_human_readable_formatter.py

@@ -28,6 +28,36 @@ def test_human_readable_formatter_model(
     formatter.evaluable_evaluated(model1, results, Score(10.0, "🥇"))
     stdout = capsys.readouterr().out
     expected = """\
+    🥇 \x1B[1mM: model1\x1B[0m (score: 10.0)
+        \x1B[1;31mERR \x1B[0m tests.conftest.rule_severity_medium: Oh noes
+        \x1B[1;33mWARN\x1B[0m (critical) tests.conftest.rule_severity_critical: Error
+
+    """
+    assert stdout == dedent(expected)
+
+
+def test_human_readable_formatter_model_show_all(
+    capsys,
+    default_config,
+    manifest_loader,
+    model1,
+    rule_severity_low,
+    rule_severity_medium,
+    rule_severity_critical,
+):
+    """Ensure the formatter has the correct output after model evaluation."""
+    default_config.overload({"show": "all"})
+    formatter = HumanReadableFormatter(
+        manifest_loader=manifest_loader, config=default_config
+    )
+    results: EvaluableResultsType = {
+        rule_severity_low: None,
+        rule_severity_medium: Exception("Oh noes"),
+        rule_severity_critical: RuleViolation("Error"),
+    }
+    formatter.evaluable_evaluated(model1, results, Score(10.0, "🥇"))
+    stdout = capsys.readouterr().out
+    expected = """\
     🥇 \x1B[1mM: model1\x1B[0m (score: 10.0)
         \x1B[1;32mOK  \x1B[0m tests.conftest.rule_severity_low
         \x1B[1;31mERR \x1B[0m tests.conftest.rule_severity_medium: Oh noes
@@ -44,7 +74,7 @@ def test_human_readable_formatter_project(capsys, default_config, manifest_loade
     )
     formatter.project_evaluated(Score(10.0, "🥇"))
     stdout = capsys.readouterr().out
-    assert stdout == "Project score: \x1B[1m10.0\x1B[0m 🥇\n"
+    assert stdout == "Project score: \x1b[1m10.0\x1b[0m 🥇\n"
 
 
 def test_human_readable_formatter_near_perfect_model_score(
@@ -57,6 +87,7 @@ def test_human_readable_formatter_near_perfect_model_score(
     rule_severity_critical,
 ):
     """Ensure the formatter has the correct output after model evaluation."""
+    default_config.overload({"show": "all"})
     formatter = HumanReadableFormatter(
         manifest_loader=manifest_loader, config=default_config
     )
@@ -87,7 +118,7 @@ def test_human_readable_formatter_near_perfect_project_score(
     )
     formatter.project_evaluated(Score(9.99, "🥈"))
     stdout = capsys.readouterr().out
-    assert stdout == "Project score: \x1B[1m9.9\x1B[0m 🥈\n"
+    assert stdout == "Project score: \x1b[1m9.9\x1b[0m 🥈\n"
 
 
 def test_human_readable_formatter_low_evaluable_score(
@@ -126,14 +157,19 @@ def test_human_readable_formatter_low_evaluable_score(
     assert stdout == dedent(expected)
 
 
-def test_human_readable_formatter_low_project_score(
+def test_human_readable_formatter_low_project_score_high_model_score(
     capsys,
     default_config,
     manifest_loader,
     model1,
     rule_severity_critical,
 ):
-    """Ensure the formatter has the correct output when the projet has a low score."""
+    """Ensure the formatter has the correct output when the projet has a low score.
+
+    If model itself has a high project score then we need to pass `show_all` flag
+    to make it visible.
+    """
+    default_config.overload({"show_all": True})
     formatter = HumanReadableFormatter(
         manifest_loader=manifest_loader, config=default_config
     )

tests/test_cli.py

@@ -21,7 +21,7 @@ def test_lint_existing_manifest(manifest_path):
     """Test lint with an existing manifest."""
     with patch("dbt_score.cli.Config._load_toml_file"):
         runner = CliRunner()
-        result = runner.invoke(lint, ["--manifest", manifest_path])
+        result = runner.invoke(lint, ["--manifest", manifest_path, "--show", "all"])
 
         assert "model1" in result.output
         assert "model2" in result.output
@@ -112,7 +112,6 @@ def test_fail_any_model_under(manifest_path):
         result = runner.invoke(
             lint, ["--manifest", manifest_path, "--fail-any-item-under", "10.0"]
         )
-
         assert "model1" in result.output
         assert "model2" in result.output
         assert "Error: evaluable score too low, fail_any_item_under" in result.stdout