Redesign class Caption(urwid.Text) and fix bug

- Caption is now composed of a CaptionParts namedtuple and a separator, both will be
  passed to Caption explicitly

- separator and parts in CaptionParts will be tuples of the form
  (attribute, text), similar to text markup in urwid

- Caption no longer overestimates the amount of text to be removed.

Author: qhuy4119

pudb/debugger.py

@@ -529,7 +529,8 @@ def _runmodule(self, module_name):
 # UI stuff --------------------------------------------------------------------
 
 from pudb.ui_tools import make_hotkey_markup, labelled_value, \
-        SelectableText, SignalWrap, StackFrame, BreakpointFrame
+        SelectableText, SignalWrap, StackFrame, BreakpointFrame, \
+        Caption, CaptionParts
 
 from pudb.var_view import FrameVarInfoKeeper
 
@@ -858,8 +859,7 @@ def helpside(w, size, key):
                         ],
                     dividechars=1)
 
-        from pudb.ui_tools import Caption
-        self.caption = Caption("")
+        self.caption = Caption(CaptionParts(*[(None, "")]*4))
         header = urwid.AttrMap(self.caption, "header")
         self.top = SignalWrap(urwid.Frame(
             urwid.AttrMap(self.columns, "background"),
@@ -2618,35 +2618,26 @@ def interaction(self, exc_tuple, show_exc_dialog=True):
         self.current_exc_tuple = exc_tuple
 
         from pudb import VERSION
-        separator = " - "
-        pudb_version = "PuDB %s" % VERSION
-        hotkey = "?:help"
+        pudb_version = (None, "PuDB %s" % VERSION)
+        hotkey = (None, "?:help")
         if self.source_code_provider.get_source_identifier():
-            source_filename = self.source_code_provider.get_source_identifier()
+            filename = (None, self.source_code_provider.get_source_identifier())
         else:
-            source_filename = "source filename is unavailable"
-        caption = [(None, pudb_version),
-                (None, separator),
-                (None, hotkey),
-                (None, separator),
-                (None, source_filename)
-                ]
+            filename = (None, "source filename is unavailable")
+        optional_alert = (None, "")
 
         if self.debugger.post_mortem:
             if show_exc_dialog and exc_tuple is not None:
                 self.show_exception_dialog(exc_tuple)
 
-            caption.extend([
-                (None, separator),
-                ("warning", "[POST-MORTEM MODE]")
-                ])
+            optional_alert = ("warning", "[POST-MORTEM MODE]")
+
         elif exc_tuple is not None:
-            caption.extend([
-                (None, separator),
-                ("warning", "[PROCESSING EXCEPTION, hit 'e' to examine]")
-                ])
+            optional_alert = \
+                    ("warning", "[PROCESSING EXCEPTION, hit 'e' to examine]")
 
-        self.caption.set_text(caption)
+        self.caption.set_text(CaptionParts(
+            pudb_version, hotkey, filename, optional_alert))
         self.event_loop()
 
     def set_source_code_provider(self, source_code_provider, force_update=False):

pudb/ui_tools.py

@@ -333,60 +333,92 @@ def keypress(self, size, key):
         return result
 
 
+from collections import namedtuple
+caption_parts = ["pudb_version", "hotkey", "full_source_filename", "optional_alert"]
+CaptionParts = namedtuple(
+    "CaptionParts",
+    caption_parts,
+    )
+
+
 class Caption(urwid.Text):
-    def __init__(self, markup, separator=" - "):
+    """
+    A text widget that will automatically shorten its content
+    to fit in 1 row if needed
+    """
+
+    def __init__(self, caption_parts, separator=(None, " - ")):
         self.separator = separator
-        super().__init__(markup)
-
-    def set_text(self, markup):
-        super().set_text(markup)
-        if len(markup) > 0:
-            # Assume the format of caption is:
-            # <PuDB version> <hotkey> <source filename> [optional_alert]
-            caption, _ = self.get_text()
-            caption_elements = caption.split(self.separator)
-            self.pudb_version = caption_elements[0]
-            self.hotkey = caption_elements[1]
-            self.full_source_filename = caption_elements[2]
-            self.optional_alert = caption_elements[3] if len(
-                caption_elements) > 3 else ""
-        else:
-            self.pudb_version = self.hotkey = ""
-            self.full_source_filename = self.optional_alert = ""
+        super().__init__(caption_parts)
+
+    def __str__(self):
+        caption_text = self.separator[1].join(
+            [part[1] for part in self.caption_parts]).rstrip(self.separator[1])
+        return caption_text
+
+    @property
+    def markup(self):
+        """
+        Returns markup of str(self) by inserting the markup of
+        self.separator between each item in self.caption_parts
+        """
+
+        # Reference: https://stackoverflow.com/questions/5920643/add-an-item-between-each-item-already-in-the-list # noqa
+        markup = [self.separator] * (len(self.caption_parts) * 2 - 1)
+        markup[0::2] = self.caption_parts
+        if not self.caption_parts.optional_alert[1]:
+            markup = markup[:-2]
+        return markup
+
+    def render(self, size, focus=False):
+        markup = self._get_fit_width_markup(size)
+        return urwid.Text(markup).render(size)
+
+    def set_text(self, caption_parts):
+        super().set_text([*caption_parts])
+        self.caption_parts = caption_parts
 
     def rows(self, size, focus=False):
         # Always return 1 to avoid
-        # `assert head.rows() == hrows, "rows, render mismatch")`
+        # AssertionError: `assert head.rows() == hrows, "rows, render mismatch")`
         # in urwid.Frame.render() in urwid/container.py
         return 1
 
-    def render(self, size, focus=False):
+    def _get_fit_width_markup(self, size):
+        if urwid.Text(str(self)).rows(size) == 1:
+            return self.markup
+        FILENAME_MARKUP_INDEX = 4
         maxcol = size[0]
-        if super().rows(size) > 1:
-            filename = self.get_shortened_source_filename(size)
-        else:
-            filename = self.full_source_filename
-        caption = self.separator.join(
-            [self.pudb_version, self.hotkey, filename, self.optional_alert]
-            ).strip(self.separator)
-        if self.optional_alert:
-            attr = [("warning", len(caption))]
-        else:
-            attr = [(None, 0)]
-
-        return make_canvas([caption], [attr], maxcol)
+        markup = self.markup
+        markup[FILENAME_MARKUP_INDEX] = (
+            markup[FILENAME_MARKUP_INDEX][0],
+            self._get_shortened_source_filename(size))
+        caption = urwid.Text(markup)
+        while True:
+            if caption.rows(size) == 1:
+                return markup
+            else:
+                for i in range(len(markup)):
+                    clip_amount = len(caption.get_text()[0]) - maxcol
+                    markup[i] = (markup[i][0], markup[i][1][clip_amount:])
+                    caption = urwid.Text(markup)
 
-    def get_shortened_source_filename(self, size):
+    def _get_shortened_source_filename(self, size):
         import os
         maxcol = size[0]
 
-        occupied_width = (len(self.pudb_version) + len(self.hotkey)
-                          + len(self.optional_alert) + len(self.separator)*3)
-        available_width = maxcol - occupied_width
-        trim_index = len(self.full_source_filename) - available_width
-        filename = self.full_source_filename[trim_index:]
-        first_dirname_index = filename.find(os.sep)
-        filename = filename[first_dirname_index + 1:]
+        occupied_width = len(str(self)) - \
+                             len(self.caption_parts.full_source_filename[1])
+        available_width = max(0, maxcol - occupied_width)
+        trim_index = len(
+            self.caption_parts.full_source_filename[1]) - available_width
+        filename = self.caption_parts.full_source_filename[1][trim_index:]
 
-        return filename
+        if self.caption_parts.full_source_filename[1][trim_index-1] == os.sep:
+            #filename starts with the full name of a directory or file
+            return filename
+        else:
+            first_path_sep_index = filename.find(os.sep)
+            filename = filename[first_path_sep_index + 1:]
+            return filename
 # }}}

test/test_caption.py

@@ -0,0 +1,164 @@
+from pudb.ui_tools import Caption, CaptionParts
+import pytest
+import urwid
+
+
+@pytest.fixture
+def text_markups():
+    from collections import namedtuple
+    Markups = namedtuple("Markups",
+            ["pudb_version", "hotkey", "full_source_filename",
+                "alert", "default_separator", "custom_separator"])
+
+    pudb_version = (None, "PuDB VERSION")
+    hotkey = (None, "?:help")
+    full_source_filename = (None, "/home/foo - bar/baz.py")
+    alert = ("warning", "[POST-MORTEM MODE]")
+    default_separator = (None, " - ")
+    custom_separator = (None, " | ")
+    return Markups(pudb_version, hotkey, full_source_filename,
+            alert, default_separator, custom_separator)
+
+
+@pytest.fixture
+def captions(text_markups):
+    empty = CaptionParts(*[(None, "")]*4)
+    always_display = [
+            text_markups.pudb_version, text_markups.hotkey,
+            text_markups.full_source_filename]
+    return {"empty": Caption(empty),
+            "without_alert": Caption(CaptionParts(*always_display, (None, ""))),
+            "with_alert": Caption(CaptionParts(*always_display, text_markups.alert)),
+            "custom_separator": Caption(CaptionParts(*always_display, (None, "")),
+                separator=text_markups.custom_separator),
+            }
+
+
+def test_init(captions):
+    for key in ["empty", "without_alert", "with_alert"]:
+        assert captions[key].separator == (None, " - ")
+    assert captions["custom_separator"].separator == (None, " | ")
+
+
+def test_str(captions):
+    assert str(captions["empty"]) == ""
+    assert str(captions["without_alert"]
+               ) == "PuDB VERSION - ?:help - /home/foo - bar/baz.py"
+    assert str(captions["with_alert"]
+               ) == "PuDB VERSION - ?:help - /home/foo - bar/baz.py - [POST-MORTEM MODE]"  # noqa
+    assert str(captions["custom_separator"]
+               ) == "PuDB VERSION | ?:help | /home/foo - bar/baz.py"
+
+
+def test_markup(captions):
+    assert captions["empty"].markup \
+        == [(None, ""), (None, " - "),
+            (None, ""), (None, " - "),
+            (None, "")]
+
+    assert captions["without_alert"].markup \
+        == [(None, "PuDB VERSION"), (None, " - "),
+            (None, "?:help"), (None, " - "),
+            (None, "/home/foo - bar/baz.py")]
+
+    assert captions["with_alert"].markup \
+       == [(None, "PuDB VERSION"), (None, " - "),
+            (None, "?:help"), (None, " - "),
+            (None, "/home/foo - bar/baz.py"), (None, " - "),
+            ("warning", "[POST-MORTEM MODE]")]
+
+    assert captions["custom_separator"].markup \
+        == [(None, "PuDB VERSION"), (None, " | "),
+            (None, "?:help"), (None, " | "),
+            (None, "/home/foo - bar/baz.py")]
+
+
+def test_render(captions):
+    for k in captions.keys():
+        sizes = {"wider_than_caption": (max(1, len(str(captions[k])) + 1), ),
+                "equals_caption": (max(1, len(str(captions[k]))), ),
+                "narrower_than_caption": (max(1, len(str(captions[k])) - 10), ),
+                 }
+        for s in sizes:
+            got = captions[k].render(sizes[s])
+            markup = captions[k]._get_fit_width_markup(sizes[s])
+            expected = urwid.Text(markup).render(sizes[s])
+            assert list(expected.content()) == list(got.content())
+
+
+def test_set_text(captions):
+    assert captions["empty"].caption_parts == CaptionParts(*[(None, "")]*4)
+    for key in ["without_alert", "custom_separator"]:
+        assert captions[key].caption_parts \
+            == CaptionParts(
+                    (None, "PuDB VERSION"),
+                    (None, "?:help"),
+                    (None, "/home/foo - bar/baz.py"),
+                    (None, ""))
+    assert captions["with_alert"].caption_parts \
+            == CaptionParts(
+                    (None, "PuDB VERSION"),
+                    (None, "?:help"),
+                    (None, "/home/foo - bar/baz.py"),
+                    ("warning", "[POST-MORTEM MODE]"))
+
+
+def test_rows(captions):
+    for caption in captions.values():
+        assert caption.rows(size=(99999, 99999)) == 1
+        assert caption.rows(size=(80, 24)) == 1
+        assert caption.rows(size=(1, 1)) == 1
+
+
+def test_get_fit_width_markup(captions):
+    # No need to check empty caption because
+    # len(str(caption)) == 0 always smaller than min terminal column == 1
+
+    # Set up
+    caption = captions["with_alert"]
+    caption_length = len(str(caption))
+    full_source_filename = caption.caption_parts.full_source_filename[1]
+    cut_only_filename = (
+        max(1, caption_length - len(full_source_filename) + 5), )
+    cut_more_than_filename = (max(1, caption_length
+            - len(full_source_filename) - len("PuDB VE")), )
+    sizes = {"cut_only_filename": cut_only_filename,
+            "cut_more_than_filename": cut_more_than_filename,
+            "one_col": (1, ),
+             }
+    # Test
+    assert caption._get_fit_width_markup(sizes["cut_only_filename"]) \
+        == [(None, "PuDB VERSION"), (None, " - "),
+            (None, "?:help"), (None, " - "),
+            (None, "az.py"), (None, " - "), ("warning", "[POST-MORTEM MODE]")]
+    assert caption._get_fit_width_markup(sizes["cut_more_than_filename"]) \
+        == [(None, "RSION"), (None, " - "),
+            (None, "?:help"), (None, " - "),
+            (None, ""), (None, " - "), ("warning", "[POST-MORTEM MODE]")]
+    assert caption._get_fit_width_markup(sizes["one_col"]) \
+       == [(None, "")]*6 + [("warning", "]")]
+
+
+def test_get_shortened_source_filename(captions):
+    # No need to check empty caption because
+    # len(str(caption)) == 0 always smaller than min terminal column == 1
+    for k in ["with_alert", "without_alert", "custom_separator"]:
+        caption_length = len(str(captions[k]))
+        sizes = {"cut_at_path_sep": (max(1, caption_length - 1), ),
+                "lose_some_dir": (max(1, caption_length - 2), ),
+                "lose_all_dir": (max(1,
+                    caption_length - len("/home/foo - bar/")), ),
+                "lose_some_filename_chars": (max(1,
+                    caption_length - len("/home/foo - bar/ba")), ),
+                "lose_all": (max(1,
+                    caption_length - len("/home/foo - bar/baz.py")), ),
+                 }
+        assert captions[k]._get_shortened_source_filename(sizes["cut_at_path_sep"]) \
+                == "home/foo - bar/baz.py"
+        assert captions[k]._get_shortened_source_filename(sizes["lose_some_dir"]) \
+                == "foo - bar/baz.py"
+        assert captions[k]._get_shortened_source_filename(sizes["lose_all_dir"]) \
+                == "baz.py"
+        assert captions[k]._get_shortened_source_filename(
+            sizes["lose_some_filename_chars"]) == "z.py"
+        assert captions[k]._get_shortened_source_filename(sizes["lose_all"]) == ""