new: Overhaul truncation system; move markdown output to Rich (#502)

## 📝 Description

This PR makes a number of changes to the CLI's output system, including:
- The removal of the legacy truncation system in favor of dynamic
truncation through Rich
- The removal of the legacy markdown output method in favor of Rich's
markdown box style
- The addition of a new `--column-width` field to specify the maximum
width of each column in an output table

## ✔️ How to Test

```
make testunit
```

Author: lgarber-akamai

linodecli/__init__.py

@@ -100,6 +100,7 @@ def main():  # pylint: disable=too-many-branches,too-many-statements
 
     cli.output_handler.suppress_warnings = parsed.suppress_warnings
     cli.output_handler.disable_truncation = parsed.no_truncation
+    cli.output_handler.column_width = parsed.column_width
 
     if parsed.as_user and not skip_config:
         cli.config.set_user(parsed.as_user)

linodecli/arg_helpers.py

@@ -126,6 +126,13 @@ def register_args(parser):
         default=False,
         help="Prevent the truncation of long values in command outputs.",
     )
+    parser.add_argument(
+        "--column-width",
+        type=int,
+        default=None,
+        help="Sets the maximum width of each column in outputted tables. "
+        "By default, columns are dynamically sized to fit the terminal.",
+    )
     parser.add_argument(
         "--version",
         "-v",

linodecli/output.py

@@ -2,14 +2,14 @@
 Handles formatting the output of commands used in Linode CLI
 """
 import json
-import sys
 from enum import Enum
 from sys import stdout
-from typing import IO, List, Optional, Union
+from typing import IO, List, Optional, Union, cast
 
 from rich import box
 from rich import print as rprint
-from rich.table import Table
+from rich.console import OverflowMethod
+from rich.table import Column, Table
 from rich.text import Text
 
 from linodecli.baked.response import OpenAPIResponse
@@ -40,18 +40,19 @@ def __init__(  # pylint: disable=too-many-arguments
         pretty_json=False,
         columns=None,
         disable_truncation=False,
-        truncation_length=64,
         suppress_warnings=False,
+        column_width=None,
     ):
         self.mode = mode
         self.delimiter = delimiter
         self.pretty_json = pretty_json
         self.headers = headers
         self.columns = columns
-        self.disable_truncation = disable_truncation
-        self.truncation_length = truncation_length
         self.suppress_warnings = suppress_warnings
 
+        self.disable_truncation = disable_truncation
+        self.column_width = column_width
+
         # Used to track whether a warning has already been printed
         self.has_warned = False
 
@@ -82,14 +83,14 @@ def print(
                 header, data, columns, title, to
             ),
             OutputMode.ascii_table: lambda: self._table_output(
-                header, data, columns, title, to, box.ASCII
+                header, data, columns, title, to, box_style=box.ASCII
             ),
             OutputMode.delimited: lambda: self._delimited_output(
                 header, data, columns, to
             ),
             OutputMode.json: lambda: self._json_output(header, data, to),
-            OutputMode.markdown: lambda: self._markdown_output(
-                header, data, columns, to
+            OutputMode.markdown: lambda: self._table_output(
+                header, data, columns, title, to, box_style=box.MARKDOWN
             ),
         }
 
@@ -143,13 +144,27 @@ def _table_output(
         content = self._build_output_content(
             data,
             columns,
-            value_transform=lambda attr, v: self._attempt_truncate_value(
-                attr.render_value(v)
-            ),
+            value_transform=lambda attr, v: str(attr.render_value(v)),
+        )
+
+        # Determine the rich overflow mode to use
+        # for each column.
+        overflow_mode = cast(
+            OverflowMethod, "fold" if self.disable_truncation else "ellipsis"
         )
 
+        # Convert the headers into column objects
+        # so we can override the overflow method.
+        header_columns = [
+            Column(v, overflow=overflow_mode, max_width=self.column_width)
+            for v in header
+        ]
+
         tab = Table(
-            *header, header_style="", box=box_style, show_header=self.headers
+            *header_columns,
+            header_style="",
+            box=box_style,
+            show_header=self.headers,
         )
         for row in content:
             row = [Text.from_ansi(item) for item in row]
@@ -212,26 +227,6 @@ def _select_json_elements(keys, json_res):
                     ret[k] = v
         return ret
 
-    def _markdown_output(self, header, data, columns, to):
-        """
-        Pretty-prints data in a Markdown-formatted table.  This uses github's
-        flavor of Markdown
-        """
-        content = self._build_output_content(
-            data,
-            columns,
-            value_transform=lambda attr, v: self._attempt_truncate_value(
-                attr.render_value(v, colorize=False)
-            ),
-        )
-
-        if header:
-            print("| " + " | ".join([str(c) for c in header]) + " |", file=to)
-            print("|---" * len(header) + "|", file=to)
-
-        for row in content:
-            print("| " + " | ".join([str(c) for c in row]) + " |", file=to)
-
     def _build_output_content(
         self,
         data,
@@ -258,25 +253,3 @@ def _build_output_content(
             content.append([value_transform(attr, model) for attr in columns])
 
         return content
-
-    def _attempt_truncate_value(self, value):
-        if not isinstance(value, str):
-            value = str(value)
-
-        if self.disable_truncation:
-            return value
-
-        if len(value) < self.truncation_length:
-            return value
-
-        if not self.suppress_warnings and not self.has_warned:
-            print(
-                "Certain values in this output have been truncated. "
-                "To disable output truncation, use --no-truncation. "
-                "Alternatively, use the --json or --text output modes, "
-                "or disable warnings using --suppress-warnings.",
-                file=sys.stderr,
-            )
-            self.has_warned = True
-
-        return f"{value[:self.truncation_length]}..."

tests/unit/test_output.py

@@ -13,48 +13,6 @@ class TestOutputHandler:
     Unit tests for linodecli.output
     """
 
-    def test_markdown_output_columns(self, mock_cli):
-        output = io.StringIO()
-
-        output_handler = mock_cli.output_handler
-
-        output_handler._markdown_output(
-            ["very cool header", "wow"],
-            [["foo", "bar"], ["oof", "rab"]],
-            ["1", "2"],
-            output,
-        )
-
-        assert (
-            output.getvalue() == "| very cool header | wow |\n"
-            "|---|---|\n"
-            "| foo | bar |\n"
-            "| oof | rab |\n"
-        )
-
-    def test_markdown_output_models(
-        self, mock_cli, list_operation_for_output_tests
-    ):
-        output = io.StringIO()
-
-        output_handler = mock_cli.output_handler
-
-        attr = list_operation_for_output_tests.response_model.attrs[0]
-
-        output_handler._markdown_output(
-            ["very cool header"],
-            [{"cool": "foo"}, {"cool": "bar"}],
-            [attr],
-            output,
-        )
-
-        assert (
-            output.getvalue() == "| very cool header |\n"
-            "|---|\n"
-            "| foo |\n"
-            "| bar |\n"
-        )
-
     def test_json_output_delimited(self, mock_cli):
         output = io.StringIO()
         headers = ["foo", "bar"]
@@ -297,46 +255,13 @@ def test_print(self, mock_cli, list_operation_for_output_tests):
             in output.getvalue()
         )
 
-    def test_truncation(self, mock_cli):
-        stderr_buf = io.StringIO()
-        test_str = "x" * 80
-        test_str_truncated = f"{'x' * 64}..."
-
-        with contextlib.redirect_stderr(stderr_buf):
-            result = mock_cli.output_handler._attempt_truncate_value(test_str)
-
-        assert "truncation" in stderr_buf.getvalue()
-        assert result == test_str_truncated
-
-        # --suppress-warnings
-        # Faster than flushing apparently
-        stderr_buf = io.StringIO()
-        mock_cli.output_handler.suppress_warnings = True
-
-        with contextlib.redirect_stderr(stderr_buf):
-            result = mock_cli.output_handler._attempt_truncate_value(test_str)
-
-        assert "truncation" not in stderr_buf
-        assert result == test_str_truncated
-
-        # --no-truncation
-        mock_cli.output_handler.disable_truncation = True
-
-        result = mock_cli.output_handler._attempt_truncate_value(test_str)
-
-        assert result == test_str
-
     def test_truncated_table(self, mock_cli, list_operation_for_output_tests):
-        # Ensure integers are properly converted
-        result = mock_cli.output_handler._attempt_truncate_value(12345)
-
-        assert result == "12345"
-        assert isinstance(result, str)
+        mock_cli.output_handler.column_width = 2
 
         output = io.StringIO()
 
         test_str = "x" * 80
-        test_str_truncated = f"{'x' * 64}..."
+        test_str_truncated = "x…"
 
         header = ["h1"]
         data = [
@@ -360,31 +285,40 @@ def test_truncated_table(self, mock_cli, list_operation_for_output_tests):
 
         assert output.getvalue() == mock_table.getvalue()
 
-    def test_truncated_markdown(
+    def test_nontruncated_table(
         self, mock_cli, list_operation_for_output_tests
     ):
-        test_str = "x" * 80
-        test_str_truncated = f"{'x' * 64}..."
+        mock_cli.output_handler.column_width = 2
+        mock_cli.output_handler.disable_truncation = True
 
         output = io.StringIO()
 
-        header = ["very cool header"]
+        test_str = "x" * 80
+        test_str_truncated = "x…"
+
+        header = ["h1"]
         data = [
             {
                 "cool": test_str,
             },
         ]
         columns = [list_operation_for_output_tests.response_model.attrs[0]]
 
-        output_handler = mock_cli.output_handler
+        mock_cli.output_handler._table_output(
+            header, data, columns, "cool table", output
+        )
 
-        output_handler._markdown_output(header, data, columns, output)
+        data[0]["cool"] = test_str_truncated
 
-        assert (
-            output.getvalue() == "| very cool header |\n"
-            "|---|\n"
-            f"| {test_str_truncated} |\n"
-        )
+        mock_table = io.StringIO()
+        tab = Table("h1", header_style="", box=box.SQUARE)
+        tab.add_row(test_str_truncated)
+        tab.title = "cool table"
+        rprint(tab, file=mock_table)
+
+        print(output.getvalue())
+
+        assert output.getvalue() != mock_table.getvalue()
 
     def test_warn_broken_output(self, mock_cli):
         stderr_buf = io.StringIO()