buttons/views: Display and sort emojis by count in EmojiPicker view.

A new reaction_count field is added to the EmojiButton class to keep
in check the number of reactions with a particular emoji on a message.

The EmojiPicker view also shows the count of reactions of a particular
emoji beside emoji_name, and the list is sorted in descending order of
emoji_count, then in ascending order of emoji_names if the count is equal.

Tests amended.

Author: zee-bit

tests/ui_tools/test_buttons.py

@@ -228,16 +228,18 @@ def test_keypress_USER_INFO(
 
 class TestEmojiButton:
     @pytest.mark.parametrize(
-        "emoji_unit, to_vary_in_message",
+        "emoji_unit, to_vary_in_message, count",
         [
             case(
                 ("working_on_it", "1f6e0", ["hammer_and_wrench", "tools"]),
                 {"reactions": [{"emoji_name": "thumbs_up", "user": [{"id": 232}]}]},
+                0,
                 id="emoji_button_with_no_reaction",
             ),
             case(
                 ("+1", "1f44d", ["thumbs_up", "like"]),
                 {"reactions": [{"emoji_name": "+1", "user": [{"id": 10}]}]},
+                1,
                 id="emoji_button_with_a_reaction",
             ),
         ],
@@ -248,9 +250,11 @@ def test_init_calls_top_button(
         emoji_unit: Tuple[str, str, List[str]],
         to_vary_in_message: Dict[str, Any],
         message_fixture: Message,
+        count: int,
     ) -> None:
         controller = mocker.Mock()
         controller.model.has_user_reacted_to_message = mocker.Mock(return_value=False)
+        update_widget = mocker.patch(MODULE + ".EmojiButton.update_widget")
         top_button = mocker.patch(MODULE + ".TopButton.__init__")
         caption = ", ".join([emoji_unit[0], *emoji_unit[2]])
         message_fixture["reactions"] = to_vary_in_message["reactions"]
@@ -259,6 +263,7 @@ def test_init_calls_top_button(
             controller=controller,
             emoji_unit=emoji_unit,
             message=message_fixture,
+            reaction_count=count,
             is_selected=lambda *_: False,
             toggle_selection=lambda *_: None,
         )
@@ -270,15 +275,16 @@ def test_init_calls_top_button(
             show_function=emoji_button.update_emoji_button,
         )
         assert emoji_button.emoji_name == emoji_unit[0]
+        assert emoji_button.reaction_count == count
 
     @pytest.mark.parametrize("key", keys_for_command("ENTER"))
     @pytest.mark.parametrize(
-        "emoji, has_user_reacted, is_selected_final",
+        "emoji, has_user_reacted, is_selected_final, expected_reaction_count",
         [
-            case(("smile", "1f642", []), True, False, id="reacted_unselected_emoji"),
-            case(("smile", "1f642", []), True, True, id="reacted_selected_emoji"),
-            case(("+1", "1f44d", []), False, False, id="unreacted_unselected_emoji"),
-            case(("+1", "1f44d", []), False, True, id="unreacted_selected_emoji"),
+            case(("smile", "1f642", []), True, False, 2, id="reacted_unselected_emoji"),
+            case(("smile", "1f642", []), True, True, 0, id="reacted_selected_emoji"),
+            case(("+1", "1f44d", []), False, False, 0, id="unreacted_unselected_emoji"),
+            case(("+1", "1f44d", []), False, True, 2, id="unreacted_selected_emoji"),
         ],
     )
     def test_keypress_emoji_button(
@@ -290,6 +296,7 @@ def test_keypress_emoji_button(
         is_selected_final: bool,
         widget_size: Callable[[Widget], urwid_Size],
         message_fixture: Message,
+        expected_reaction_count: int,
     ) -> None:
         controller = mocker.Mock()
         controller.model.has_user_reacted_to_message = mocker.Mock(
@@ -307,15 +314,23 @@ def test_keypress_emoji_button(
             controller=controller,
             emoji_unit=emoji,
             message=message_fixture,
+            reaction_count=1,
             is_selected=lambda *_: is_selected_final,
             toggle_selection=lambda *_: None,
         )
         size = widget_size(emoji_button)
 
         emoji_button.keypress(size, key)
 
-        suffix_text = f"{CHECK_MARK}" if has_user_reacted != is_selected_final else ""
+        reaction_count = emoji_button.reaction_count
+        reaction_count_text = "" if reaction_count == 0 else f"{reaction_count}"
+        suffix_text = (
+            f"{CHECK_MARK} " + reaction_count_text
+            if has_user_reacted != is_selected_final
+            else reaction_count_text
+        )
         assert emoji_button.emoji_name == emoji[0]
+        assert reaction_count == expected_reaction_count
         assert emoji_button.button_suffix.get_text()[0].strip() == suffix_text
 
 

zulipterminal/ui_tools/buttons.py

@@ -328,12 +328,14 @@ def __init__(
         controller: Any,
         emoji_unit: Tuple[str, str, List[str]],  # (emoji_name, emoji_code, aliases)
         message: Message,
+        reaction_count: int = 0,
         is_selected: Callable[[str], bool],
         toggle_selection: Callable[[str, str], None],
     ) -> None:
         self.controller = controller
         self.message = message
         self.is_selected = is_selected
+        self.reaction_count = reaction_count
         self.toggle_selection = toggle_selection
         self.emoji_name, self.emoji_code, self.aliases = emoji_unit
         full_button_caption = ", ".join([self.emoji_name, *self.aliases])
@@ -344,20 +346,31 @@ def __init__(
             prefix_character="",
             show_function=self.update_emoji_button,
         )
-        if self._has_user_reacted_to_msg() or is_selected(self.emoji_name):
-            self.update_widget((None, f" {CHECK_MARK} "), None)
+
+        has_check_mark = self._has_user_reacted_to_msg() or is_selected(self.emoji_name)
+        self.update_widget((None, self.get_update_widget_text(has_check_mark)), None)
 
     def _has_user_reacted_to_msg(self) -> bool:
         return self.controller.model.has_user_reacted_to_message(
             self.message, emoji_code=self.emoji_code
         )
 
+    def get_update_widget_text(self, user_reacted: bool) -> str:
+        count_text = str(self.reaction_count) if self.reaction_count > 0 else ""
+        reacted_check_mark = CHECK_MARK if user_reacted else ""
+        return f" {reacted_check_mark} {count_text} "
+
     def update_emoji_button(self) -> None:
         self.toggle_selection(self.emoji_code, self.emoji_name)
         is_reaction_added = self._has_user_reacted_to_msg() != self.is_selected(
             self.emoji_name
         )
-        self.update_widget((None, f" {CHECK_MARK} " if is_reaction_added else ""), None)
+        self.reaction_count = (
+            (self.reaction_count + 1)
+            if is_reaction_added
+            else (self.reaction_count - 1)
+        )
+        self.update_widget((None, self.get_update_widget_text(is_reaction_added)), None)
 
 
 class DecodedStream(TypedDict):

zulipterminal/ui_tools/views.py

@@ -2008,19 +2008,31 @@ def add_or_remove_selected_emoji(self, emoji_code: str, emoji_name: str) -> None
         else:
             self.selected_emojis.update({emoji_code: emoji_name})
 
+    def count_reactions(self, emoji_code: str) -> int:
+        num_reacts = 0
+        for reaction in self.message["reactions"]:
+            if reaction["emoji_code"] == emoji_code:
+                num_reacts += 1
+        return num_reacts
+
     def generate_emoji_buttons(
         self, emoji_units: List[Tuple[str, str, List[str]]]
     ) -> List[EmojiButton]:
-        return [
+        emoji_buttons = [
             EmojiButton(
                 controller=self.controller,
                 emoji_unit=emoji_unit,
                 message=self.message,
+                reaction_count=self.count_reactions(emoji_unit[1]),
                 is_selected=self.is_selected_emoji,
                 toggle_selection=self.add_or_remove_selected_emoji,
             )
             for emoji_unit in emoji_units
         ]
+        sorted_emoji_buttons = sorted(
+            emoji_buttons, key=lambda button: button.reaction_count, reverse=True
+        )
+        return sorted_emoji_buttons
 
     def keypress(self, size: urwid_Size, key: str) -> str:
         if (