Updated argparse_completer to use TableCreator for the hint table

5 files changed, 133 insertions, 74 deletions

diff --git a/cmd2/argparse_completer.py b/cmd2/argparse_completer.py
index 61f173cc..a8bb6390 100644
--- a/cmd2/argparse_completer.py
+++ b/cmd2/argparse_completer.py
@@ -14,6 +14,8 @@ from collections import deque
 from typing import Dict, List, Optional, Union
 
 from . import ansi, cmd2, constants
+from .table_creator import Column, SimpleTable
+
 from .argparse_custom import (
     ATTR_CHOICES_CALLABLE,
     ATTR_DESCRIPTIVE_COMPLETION_HEADER,
@@ -467,29 +469,36 @@ class ArgparseCompleter:
 
             # If a metavar was defined, use that instead of the dest field
             destination = action.metavar if action.metavar else action.dest
-            token_width = ansi.style_aware_wcswidth(destination)
-            completions_with_desc = []
-
-            for item in completions:
-                item_width = ansi.style_aware_wcswidth(item)
-                if item_width > token_width:
-                    token_width = item_width
-
-            term_size = shutil.get_terminal_size()
-            fill_width = int(term_size.columns * .6) - (token_width + 2)
-            for item in completions:
-                entry = '{: <{token_width}}{: <{fill_width}}'.format(item, item.description,
-                                                                     token_width=token_width + 2,
-                                                                     fill_width=fill_width)
-                completions_with_desc.append(entry)
 
             desc_header = getattr(action, ATTR_DESCRIPTIVE_COMPLETION_HEADER, None)
             if desc_header is None:
                 desc_header = DEFAULT_DESCRIPTIVE_HEADER
-            header = '\n{: <{token_width}}{}'.format(destination.upper(), desc_header, token_width=token_width + 2)
 
-            self._cmd2_app.completion_header = header
-            self._cmd2_app.display_matches = completions_with_desc
+            # Calculate needed widths for the token and description columns of the table
+            token_width = ansi.style_aware_wcswidth(destination)
+            desc_width = ansi.style_aware_wcswidth(desc_header)
+
+            for item in completions:
+                token_width = max(ansi.style_aware_wcswidth(item), token_width)
+                desc_width = max(ansi.style_aware_wcswidth(item.description), desc_width)
+
+            # Create a table that's over half the width of the terminal.
+            # This will force readline to place each entry on its own line.
+            divider_char = None
+            min_width = int(shutil.get_terminal_size().columns * 0.6)
+            base_width = SimpleTable.base_width(2, divider_char=divider_char)
+            initial_width = base_width + token_width + desc_width
+
+            if initial_width < min_width:
+                desc_width += (min_width - initial_width)
+
+            cols = list()
+            cols.append(Column(destination.upper(), width=token_width))
+            cols.append(Column(desc_header, width=desc_width))
+
+            hint_table = SimpleTable(cols, divider_char=divider_char)
+            self._cmd2_app.completion_header = hint_table.generate_header()
+            self._cmd2_app.display_matches = [hint_table.generate_data_row([item, item.description]) for item in completions]
 
         return completions
 
diff --git a/cmd2/cmd2.py b/cmd2/cmd2.py
index 49c181f1..7245273a 100644
--- a/cmd2/cmd2.py
+++ b/cmd2/cmd2.py
@@ -1147,7 +1147,7 @@ class Cmd(cmd.Cmd):
 
             # Print the header if one exists
             if self.completion_header:
-                sys.stdout.write('\n' + self.completion_header)
+                sys.stdout.write('\n\n' + self.completion_header)
 
             # Call readline's display function
             # rl_display_match_list(strings_array, number of completion matches, longest match length)
@@ -1176,7 +1176,7 @@ class Cmd(cmd.Cmd):
             # Print the header if one exists
             if self.completion_header:
                 # noinspection PyUnresolvedReferences
-                readline.rl.mode.console.write('\n' + self.completion_header)
+                readline.rl.mode.console.write('\n\n' + self.completion_header)
 
             # Display matches using actual display function. This also redraws the prompt and line.
             orig_pyreadline_display(matches_to_display)
diff --git a/cmd2/table_creator.py b/cmd2/table_creator.py
index 70b7c1eb..dce9462e 100644
--- a/cmd2/table_creator.py
+++ b/cmd2/table_creator.py
@@ -465,8 +465,9 @@ class TableCreator:
                 if cell_index == len(self.cols) - 1:
                     row_buf.write(post_line)
 
-            # Add a newline if this is not the last row
-            row_buf.write('\n')
+            # Add a newline if this is not the last line
+            if line_index < total_lines - 1:
+                row_buf.write('\n')
 
         return row_buf.getvalue()
 
@@ -480,6 +481,9 @@ class SimpleTable(TableCreator):
     Implementation of TableCreator which generates a borderless table with an optional divider row after the header.
     This class can be used to create the whole table at once or one row at a time.
     """
+    # Num chars between cells
+    INTER_CELL_CHARS = 2
+
     def __init__(self, cols: Sequence[Column], *, tab_width: int = 4, divider_char: Optional[str] = '-') -> None:
         """
         SimpleTable initializer
@@ -495,24 +499,50 @@ class SimpleTable(TableCreator):
         self.divider_char = divider_char
         self.empty_data = [EMPTY for _ in self.cols]
 
-    def generate_header(self) -> str:
+    @staticmethod
+    def base_width(num_cols: int, divider_char: Optional[str] = '-') -> int:
         """
-        Generate header with an optional divider row
+        Utility method to calculate the width required for a table before data is added to it.
+        This is useful to know how much room is left for data with creating a table of a specific width.
+
+        :param num_cols: how many columns the table will have
+        :param divider_char: optional character used to build the header divider row. If provided, its value must meet the
+                             same requirements as fill_char in TableCreator.generate_row() or exceptions will be raised.
+                             Set this to None if you don't want a divider row. (Defaults to dash)
+        :return: base width
+        :raises: ValueError if num_cols is less than 1
         """
+        if num_cols < 1:
+            raise ValueError("Column count cannot be less than 1")
+
+        # Generate a line to validate divider_char. If invalid, an exception will be raised.
+        st = SimpleTable([Column('')], divider_char=divider_char)
+        st.generate_header()
+
+        if divider_char is None:
+            inter_cell = SimpleTable.INTER_CELL_CHARS * SPACE
+        else:
+            inter_cell = SPACE * ansi.style_aware_wcswidth(SimpleTable.INTER_CELL_CHARS * divider_char)
+
+        return (num_cols - 1) * ansi.style_aware_wcswidth(inter_cell)
+
+    def generate_header(self) -> str:
+        """Generate table header with an optional divider row"""
         header_buf = io.StringIO()
 
         # Create the header labels
         if self.divider_char is None:
-            inter_cell = 2 * SPACE
+            inter_cell = SimpleTable.INTER_CELL_CHARS * SPACE
         else:
-            inter_cell = SPACE * ansi.style_aware_wcswidth(2 * self.divider_char)
+            inter_cell = SPACE * ansi.style_aware_wcswidth(SimpleTable.INTER_CELL_CHARS * self.divider_char)
         header = self.generate_row(inter_cell=inter_cell)
         header_buf.write(header)
 
         # Create the divider. Use empty strings for the row_data.
         if self.divider_char is not None:
             divider = self.generate_row(row_data=self.empty_data, fill_char=self.divider_char,
-                                        inter_cell=(2 * self.divider_char))
+                                        inter_cell=(SimpleTable.INTER_CELL_CHARS * self.divider_char))
+            header_buf.write('\n')
             header_buf.write(divider)
         return header_buf.getvalue()
 
@@ -548,6 +578,8 @@ class SimpleTable(TableCreator):
         if include_header:
             header = self.generate_header()
             table_buf.write(header)
+            if len(table_data) > 0:
+                table_buf.write('\n')
 
         for index, row_data in enumerate(table_data):
             if index > 0 and row_spacing > 0:
@@ -555,6 +587,8 @@ class SimpleTable(TableCreator):
 
             row = self.generate_data_row(row_data)
             table_buf.write(row)
+            if index < len(table_data) - 1:
+                table_buf.write('\n')
 
         return table_buf.getvalue()
 
@@ -643,10 +677,7 @@ class BorderedTable(TableCreator):
                                  inter_cell=inter_cell, post_line=post_line)
 
     def generate_header(self) -> str:
-        """
-        Generate header
-        :return: header string
-        """
+        """Generate table header"""
         pre_line = '║' + self.padding * SPACE
 
         inter_cell = self.padding * SPACE
@@ -659,7 +690,9 @@ class BorderedTable(TableCreator):
         # Create the bordered header
         header_buf = io.StringIO()
         header_buf.write(self.generate_table_top_border())
+        header_buf.write('\n')
         header_buf.write(self.generate_row(pre_line=pre_line, inter_cell=inter_cell, post_line=post_line))
+        header_buf.write('\n')
         header_buf.write(self.generate_header_bottom_border())
 
         return header_buf.getvalue()
@@ -699,13 +732,17 @@ class BorderedTable(TableCreator):
             top_border = self.generate_table_top_border()
             table_buf.write(top_border)
 
+        table_buf.write('\n')
+
         for index, row_data in enumerate(table_data):
             if index > 0:
                 row_bottom_border = self.generate_row_bottom_border()
                 table_buf.write(row_bottom_border)
+                table_buf.write('\n')
 
             row = self.generate_data_row(row_data)
             table_buf.write(row)
+            table_buf.write('\n')
 
         table_buf.write(self.generate_table_bottom_border())
         return table_buf.getvalue()
@@ -797,9 +834,12 @@ class AlternatingTable(BorderedTable):
             top_border = self.generate_table_top_border()
             table_buf.write(top_border)
 
+        table_buf.write('\n')
+
         for row_data in table_data:
             row = self.generate_data_row(row_data)
             table_buf.write(row)
+            table_buf.write('\n')
 
         table_buf.write(self.generate_table_bottom_border())
         return table_buf.getvalue()
diff --git a/examples/table_creation.py b/examples/table_creation.py
index 85bfc3f0..6325b200 100755
--- a/examples/table_creation.py
+++ b/examples/table_creation.py
@@ -53,7 +53,7 @@ data_list.append(["John Jones",
 
 def ansi_print(text):
     """Wraps style_aware_write so style can be stripped if needed"""
-    ansi.style_aware_write(sys.stdout, text + '\n')
+    ansi.style_aware_write(sys.stdout, text + '\n\n')
 
 
 def main():
diff --git a/tests/test_table_creator.py b/tests/test_table_creator.py
index ed53efa6..65cb8472 100644
--- a/tests/test_table_creator.py
+++ b/tests/test_table_creator.py
@@ -70,14 +70,14 @@ def test_column_alignment():
     header = tc.generate_row()
     assert header == ('Col 1                               Three     \n'
                       '              Col 2                 line      \n'
-                      '                             Col 3  header    \n')
+                      '                             Col 3  header    ')
 
     # Create a data row
     row_data = ["Val 1", "Val 2", "Val 3", "Three\nline\ndata"]
     row = tc.generate_row(row_data=row_data)
     assert row == ('Val 1                               Three     \n'
                    '              Val 2                 line      \n'
-                   '                             Val 3  data      \n')
+                   '                             Val 3  data      ')
 
 
 def test_wrap_text():
@@ -93,13 +93,13 @@ def test_wrap_text():
                    'that will \n'
                    'wrap      \n'
                    'Not wrap  \n'
-                   ' 1  2   3 \n')
+                   ' 1  2   3 ')
 
     # Test preserving a multiple space sequence across a line break
     row_data = ['First      last one']
     row = tc.generate_row(row_data=row_data)
     assert row == ('First     \n'
-                   ' last one \n')
+                   ' last one ')
 
 
 def test_wrap_text_max_lines():
@@ -110,31 +110,31 @@ def test_wrap_text_max_lines():
     row_data = ['First line last line']
     row = tc.generate_row(row_data=row_data)
     assert row == ('First line\n'
-                   'last line \n')
+                   'last line ')
 
     # Test having to truncate the last word because it's too long for the final line
     row_data = ['First line last lineextratext']
     row = tc.generate_row(row_data=row_data)
     assert row == ('First line\n'
-                   'last line…\n')
+                   'last line…')
 
     # Test having to truncate the last word because it fits the final line but there is more text not being included
     row_data = ['First line thistxtfit extra']
     row = tc.generate_row(row_data=row_data)
     assert row == ('First line\n'
-                   'thistxtfi…\n')
+                   'thistxtfi…')
 
     # Test having to truncate the last word because it fits the final line but there are more lines not being included
     row_data = ['First line thistxtfit\nextra']
     row = tc.generate_row(row_data=row_data)
     assert row == ('First line\n'
-                   'thistxtfi…\n')
+                   'thistxtfi…')
 
     # Test having space left on the final line and adding an ellipsis because there are more lines not being included
     row_data = ['First line last line\nextra line']
     row = tc.generate_row(row_data=row_data)
     assert row == ('First line\n'
-                   'last line…\n')
+                   'last line…')
 
 
 def test_wrap_long_word():
@@ -148,7 +148,7 @@ def test_wrap_long_word():
     # Test header row
     header = tc.generate_row()
     assert header == ('LongColumn            \n'
-                      'Name        Col 2     \n')
+                      'Name        Col 2     ')
 
     # Test data row
     row_data = list()
@@ -162,7 +162,7 @@ def test_wrap_long_word():
     row = tc.generate_row(row_data=row_data)
     expected = (ansi.RESET_ALL + ansi.fg.green + "LongerThan" + ansi.RESET_ALL + "  Word      \n"
                 + ansi.RESET_ALL + ansi.fg.green + "10" + ansi.fg.reset + ansi.RESET_ALL + '        ' + ansi.RESET_ALL + '  LongerThan\n'
-                '            10        \n')
+                '            10        ')
     assert row == expected
 
 
@@ -192,7 +192,7 @@ def test_wrap_long_word_max_data_lines():
 
     row = tc.generate_row(row_data=row_data)
     assert row == ('LongerThan  LongerThan  LongerThan  A LongerT…\n'
-                   '10FitsLast  10FitsLas…  10RunsOve…            \n')
+                   '10FitsLast  10FitsLas…  10RunsOve…            ')
 
 
 def test_wrap_long_char_wider_than_max_width():
@@ -203,7 +203,7 @@ def test_wrap_long_char_wider_than_max_width():
     column_1 = Column("Col 1", width=1)
     tc = TableCreator([column_1])
     row = tc.generate_row(row_data=['深'])
-    assert row == '…\n'
+    assert row == '…'
 
 
 def test_generate_row_exceptions():
@@ -237,12 +237,12 @@ def test_tabs():
 
     row = tc.generate_row(fill_char='\t', pre_line='\t',
                           inter_cell='\t', post_line='\t')
-    assert row == '  Col  1                Col 2  \n'
+    assert row == '  Col  1                Col 2  '
 
 
 def test_simple_table():
-    column_1 = Column("Col 1", width=15)
-    column_2 = Column("Col 2", width=15)
+    column_1 = Column("Col 1", width=16)
+    column_2 = Column("Col 2", width=16)
 
     row_data = list()
     row_data.append(["Col 1 Row 1", "Col 2 Row 1"])
@@ -252,46 +252,56 @@ def test_simple_table():
     st = SimpleTable([column_1, column_2])
     table = st.generate_table(row_data)
 
-    assert table == ('Col 1            Col 2          \n'
-                     '--------------------------------\n'
-                     'Col 1 Row 1      Col 2 Row 1    \n'
+    assert table == ('Col 1             Col 2           \n'
+                     '----------------------------------\n'
+                     'Col 1 Row 1       Col 2 Row 1     \n'
                      '\n'
-                     'Col 1 Row 2      Col 2 Row 2    \n')
+                     'Col 1 Row 2       Col 2 Row 2     ')
 
     # Custom divider
     st = SimpleTable([column_1, column_2], divider_char='─')
     table = st.generate_table(row_data)
 
-    assert table == ('Col 1            Col 2          \n'
-                     '────────────────────────────────\n'
-                     'Col 1 Row 1      Col 2 Row 1    \n'
+    assert table == ('Col 1             Col 2           \n'
+                     '──────────────────────────────────\n'
+                     'Col 1 Row 1       Col 2 Row 1     \n'
+                     '\n'
+                     'Col 1 Row 2       Col 2 Row 2     ')
+
+    # Wide custom divider
+    st = SimpleTable([column_1, column_2], divider_char='深')
+    table = st.generate_table(row_data)
+
+    assert table == ('Col 1               Col 2           \n'
+                     '深深深深深深深深深深深深深深深深深深\n'
+                     'Col 1 Row 1         Col 2 Row 1     \n'
                      '\n'
-                     'Col 1 Row 2      Col 2 Row 2    \n')
+                     'Col 1 Row 2         Col 2 Row 2     ')
 
     # No divider
     st = SimpleTable([column_1, column_2], divider_char=None)
     table = st.generate_table(row_data)
 
-    assert table == ('Col 1            Col 2          \n'
-                     'Col 1 Row 1      Col 2 Row 1    \n'
+    assert table == ('Col 1             Col 2           \n'
+                     'Col 1 Row 1       Col 2 Row 1     \n'
                      '\n'
-                     'Col 1 Row 2      Col 2 Row 2    \n')
+                     'Col 1 Row 2       Col 2 Row 2     ')
 
     # No row spacing
     st = SimpleTable([column_1, column_2])
     table = st.generate_table(row_data, row_spacing=0)
-    assert table == ('Col 1            Col 2          \n'
-                     '--------------------------------\n'
-                     'Col 1 Row 1      Col 2 Row 1    \n'
-                     'Col 1 Row 2      Col 2 Row 2    \n')
+    assert table == ('Col 1             Col 2           \n'
+                     '----------------------------------\n'
+                     'Col 1 Row 1       Col 2 Row 1     \n'
+                     'Col 1 Row 2       Col 2 Row 2     ')
 
     # No header
     st = SimpleTable([column_1, column_2])
     table = st.generate_table(row_data, include_header=False)
 
-    assert table == ('Col 1 Row 1      Col 2 Row 1    \n'
+    assert table == ('Col 1 Row 1       Col 2 Row 1     \n'
                      '\n'
-                     'Col 1 Row 2      Col 2 Row 2    \n')
+                     'Col 1 Row 2       Col 2 Row 2     ')
 
     # Invalid row spacing
     st = SimpleTable([column_1, column_2])
@@ -317,7 +327,7 @@ def test_bordered_table():
                      '║ Col 1 Row 1     │ Col 2 Row 1     ║\n'
                      '╟─────────────────┼─────────────────╢\n'
                      '║ Col 1 Row 2     │ Col 2 Row 2     ║\n'
-                     '╚═════════════════╧═════════════════╝\n')
+                     '╚═════════════════╧═════════════════╝')
 
     # No column borders
     bt = BorderedTable([column_1, column_2], column_borders=False)
@@ -328,7 +338,7 @@ def test_bordered_table():
                      '║ Col 1 Row 1      Col 2 Row 1     ║\n'
                      '╟──────────────────────────────────╢\n'
                      '║ Col 1 Row 2      Col 2 Row 2     ║\n'
-                     '╚══════════════════════════════════╝\n')
+                     '╚══════════════════════════════════╝')
 
     # No header
     bt = BorderedTable([column_1, column_2])
@@ -337,7 +347,7 @@ def test_bordered_table():
                      '║ Col 1 Row 1     │ Col 2 Row 1     ║\n'
                      '╟─────────────────┼─────────────────╢\n'
                      '║ Col 1 Row 2     │ Col 2 Row 2     ║\n'
-                     '╚═════════════════╧═════════════════╝\n')
+                     '╚═════════════════╧═════════════════╝')
 
     # Non-default padding
     bt = BorderedTable([column_1, column_2], padding=2)
@@ -348,7 +358,7 @@ def test_bordered_table():
                      '║  Col 1 Row 1      │  Col 2 Row 1      ║\n'
                      '╟───────────────────┼───────────────────╢\n'
                      '║  Col 1 Row 2      │  Col 2 Row 2      ║\n'
-                     '╚═══════════════════╧═══════════════════╝\n')
+                     '╚═══════════════════╧═══════════════════╝')
 
     # Invalid padding
     with pytest.raises(ValueError) as excinfo:
@@ -372,7 +382,7 @@ def test_alternating_table():
                      '╠═════════════════╪═════════════════╣\n'
                      '║ Col 1 Row 1     │ Col 2 Row 1     ║\n'
                      '\x1b[100m║ \x1b[49m\x1b[0m\x1b[100mCol 1 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m │ \x1b[49m\x1b[0m\x1b[100mCol 2 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m ║\x1b[49m\n'
-                     '╚═════════════════╧═════════════════╝\n')
+                     '╚═════════════════╧═════════════════╝')
 
     # Other bg colors
     at = AlternatingTable([column_1, column_2], bg_odd=ansi.bg.bright_blue, bg_even=ansi.bg.green)
@@ -382,7 +392,7 @@ def test_alternating_table():
                      '╠═════════════════╪═════════════════╣\n'
                      '\x1b[104m║ \x1b[49m\x1b[0m\x1b[104mCol 1 Row 1\x1b[49m\x1b[0m\x1b[104m \x1b[49m\x1b[104m \x1b[49m\x1b[104m \x1b[49m\x1b[104m \x1b[49m\x1b[0m\x1b[104m │ \x1b[49m\x1b[0m\x1b[104mCol 2 Row 1\x1b[49m\x1b[0m\x1b[104m \x1b[49m\x1b[104m \x1b[49m\x1b[104m \x1b[49m\x1b[104m \x1b[49m\x1b[0m\x1b[104m ║\x1b[49m\n'
                      '\x1b[42m║ \x1b[49m\x1b[0m\x1b[42mCol 1 Row 2\x1b[49m\x1b[0m\x1b[42m \x1b[49m\x1b[42m \x1b[49m\x1b[42m \x1b[49m\x1b[42m \x1b[49m\x1b[0m\x1b[42m │ \x1b[49m\x1b[0m\x1b[42mCol 2 Row 2\x1b[49m\x1b[0m\x1b[42m \x1b[49m\x1b[42m \x1b[49m\x1b[42m \x1b[49m\x1b[42m \x1b[49m\x1b[0m\x1b[42m ║\x1b[49m\n'
-                     '╚═════════════════╧═════════════════╝\n')
+                     '╚═════════════════╧═════════════════╝')
 
     # No column borders
     at = AlternatingTable([column_1, column_2], column_borders=False)
@@ -392,7 +402,7 @@ def test_alternating_table():
                      '╠══════════════════════════════════╣\n'
                      '║ Col 1 Row 1      Col 2 Row 1     ║\n'
                      '\x1b[100m║ \x1b[49m\x1b[0m\x1b[100mCol 1 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m  \x1b[49m\x1b[0m\x1b[100mCol 2 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m ║\x1b[49m\n'
-                     '╚══════════════════════════════════╝\n')
+                     '╚══════════════════════════════════╝')
 
     # No header
     at = AlternatingTable([column_1, column_2])
@@ -400,7 +410,7 @@ def test_alternating_table():
     assert table == ('╔═════════════════╤═════════════════╗\n'
                      '║ Col 1 Row 1     │ Col 2 Row 1     ║\n'
                      '\x1b[100m║ \x1b[49m\x1b[0m\x1b[100mCol 1 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m │ \x1b[49m\x1b[0m\x1b[100mCol 2 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m ║\x1b[49m\n'
-                     '╚═════════════════╧═════════════════╝\n')
+                     '╚═════════════════╧═════════════════╝')
 
     # Non-default padding
     at = AlternatingTable([column_1, column_2], padding=2)
@@ -410,7 +420,7 @@ def test_alternating_table():
                      '╠═══════════════════╪═══════════════════╣\n'
                      '║  Col 1 Row 1      │  Col 2 Row 1      ║\n'
                      '\x1b[100m║  \x1b[49m\x1b[0m\x1b[100mCol 1 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m  │  \x1b[49m\x1b[0m\x1b[100mCol 2 Row 2\x1b[49m\x1b[0m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[100m \x1b[49m\x1b[0m\x1b[100m  ║\x1b[49m\n'
-                     '╚═══════════════════╧═══════════════════╝\n')
+                     '╚═══════════════════╧═══════════════════╝')
 
     # Invalid padding
     with pytest.raises(ValueError) as excinfo: