Add song temporary to queue. Song is removed once it's finished.

This closes #126

Author: sindrig

spoppy/__init__.py

@@ -10,7 +10,7 @@
 
 
 def get_version():
-    return '1.6.1'
+    return '1.7.0'
 
 
 if click:

spoppy/menus.py

@@ -689,6 +689,10 @@ def add_to_queue(self):
         self.navigator.player.add_to_queue(self.track)
         return responses.UP
 
+    def add_to_temp_queue(self):
+        self.navigator.player.add_play_then_remove(self.track)
+        return self.navigator.player
+
     def replace_current(self):
         self.navigator.player.load_playlist(
             self.playlist
@@ -712,10 +716,15 @@ def get_options(self):
                 msg,
                 self.replace_current
             )
+        formatted_track = format_track(self.track)
         results['aq'] = MenuValue(
-            'Add [%s] to queue' % format_track(self.track),
+            'Add [%s] to queue' % formatted_track,
             self.add_to_queue
         )
+        results['tmp'] = MenuValue(
+            'Add [%s] temporary to playlist' % formatted_track,
+            self.add_to_temp_queue
+        )
         if self.track.album:
             res = AlbumSelected(self.navigator)
             res.album = self.track.album.browse().load()

spoppy/players.py

@@ -94,6 +94,7 @@ def clear(self):
         self.playlist = None
         self.song_list = []
         self._trigger_redraw = False
+        self.temporary_song = None
 
     def has_been_loaded(self):
         '''
@@ -263,33 +264,34 @@ def get_ui(self):
             for song_idx in songs_to_show:
                 song = self.get_track_by_idx(song_idx)
                 right_side = right_side_items and right_side_items.pop(0)
+                extra_text = (
+                    artist_banned_text(self.navigator, song) or
+                    (
+                        self.song_order[song_idx] == self.temporary_song and
+                        '[temporary]'
+                    )
+                )
                 if song_idx == self.current_track_idx:
                     if song_idx != songs_to_show[0]:
                         # Small spacing around current...
                         res.append(('', right_side or ''))
                         right_side = (
                             right_side_items and right_side_items.pop(0)
                         )
-                    formatted_song = '>>>%s' % format_track(
-                        song,
-                        artist_banned_text(self.navigator, song)
-                    )
+                    formatted_song = '>>>%s' % format_track(song, extra_text)
                 else:
-                    formatted_song = format_track(
-                        song,
-                        artist_banned_text(self.navigator, song)
-                    )
+                    formatted_song = format_track(song, extra_text)
                 res.append((formatted_song, right_side or ''))
                 if song_idx == self.current_track_idx:
                     if song_idx != songs_to_show[-1]:
                         # Small spacing around current...
                         right_side = (
-                            right_side_items and right_side_items.pop()
+                            right_side_items and right_side_items.pop(0)
                         )
                         res.append(('', right_side or ''))
             while right_side_items:
                 # This can happend f.x. when we have one song...
-                res.append(('', right_side_items.pop()))
+                res.append(('', right_side_items.pop(0)))
         else:
             res.append('No songs found in playlist!')
 
@@ -503,6 +505,22 @@ def toggle_repeat(self):
         return NOOP
 
     # Song handling
+    def add_play_then_remove(self, item):
+        '''
+        Adds item to the current queue temporary. After the song has been added
+        it will start playing. Once it's finished or navigated from it, it will
+        be removed and the song that was playing when it was added will start
+        playing.
+        temporary_song is the index to the currently temporary song in the
+        song_list, not in song_order
+        '''
+        self.clean_temporary_song()
+        idx_of_new_item = len(self.song_list)
+        self.song_list.append(item)
+        self.song_order.insert(self.current_track_idx, idx_of_new_item)
+        self.temporary_song = idx_of_new_item
+        self.play_current_song(start_playing=True, clean_temporary=False)
+
     def add_to_queue(self, item):
         '''
         Adds item to the end of the current song list. Item can be either
@@ -522,6 +540,23 @@ def add_to_queue(self, item):
                     self.add_to_queue(track)
         self.playlist = None
 
+    def clean_temporary_song(self):
+        '''
+        If there is a temporary song in the queue, remove it from the song list
+        and make sure that the song playing before it gets selected
+        :returns: None
+        '''
+        if self.temporary_song:
+            temporary_song_index = self.song_order.index(self.temporary_song)
+            self.song_order.remove(self.temporary_song)
+            del self.song_list[self.temporary_song]
+            self.temporary_song = None
+            if temporary_song_index < self.current_track_idx:
+                # If the previous song came before the current (which happens
+                # unless the user selected the previous song) we have to
+                # select the previous song so we don't jump to the next one.
+                self.current_track_idx = self.get_prev_idx()
+
     def check_end_of_track(self):
         '''
         Checks if the current song has finished playing and starts playing
@@ -607,14 +642,22 @@ def on_end_of_track(self, session=None):
         '''
         self.end_of_track.set()
         thread.interrupt_main()
+        return False
 
-    def play_current_song(self, start_playing=True):
+    def play_current_song(self, start_playing=True, clean_temporary=True):
         '''
-        Plays the current song
+        Plays the current song.
+        Before playing these actions are performed:
+            1. Removes the temporary song if there is one.
+            2. If the current track's artist is banned, removes the current
+               song.
         :returns: None
         '''
         self.player.unload()
 
+        if clean_temporary:
+            self.clean_temporary_song()
+
         current_track = self.get_track_by_idx(self.current_track_idx)
         if not current_track:
             self.current_track = None

spoppy/util.py

@@ -52,14 +52,14 @@ def single_char_with_timeout(timeout=5):
     return response
 
 
-def format_track(track, extra_text=''):
+def format_track(track, extra_text=None):
     return '%s by %s %s' % (
         track.name,
         ' & '.join(
             artist.name for artist in track.artists
             if artist.name
         ),
-        extra_text
+        extra_text or ''
     )
 
 

tests/test_players.py

@@ -536,3 +536,28 @@ def test_get_total_playlist_length(self, patched_get_duration_from_s):
             71, max_length=None
         )
         self.assertEquals(result, expected_duration)
+
+    def test_clean_temporary_song_does_nothing_when_no_temp_song(self):
+        self.assertIsNone(self.player.clean_temporary_song())
+
+    def test_song_is_removed_if_is_temporary(self):
+        track_should_be_there = [utils.Track('Hey im here', 'duran')]
+        track_2_should_be_there = [utils.Track('Hey im here also', 'duran')]
+        track_should_not_be_there = [utils.Track('Im gone', 'Brynja')]
+        self.player.song_list = [
+            track_should_be_there,
+            track_should_not_be_there,
+            track_2_should_be_there
+        ]
+        self.player.current_track_idx = 1
+        self.player.temporary_song = 1
+        self.player.song_order = [0, 1, 2]
+
+        # We want track_2_should_be_there to be selected after removal
+        self.assertIsNone(self.player.clean_temporary_song())
+        self.assertEquals(len(self.player.song_order), 2)
+        self.assertEquals(len(self.player.song_list), 2)
+        self.assertIn(track_should_be_there, self.player.song_list)
+        self.assertIn(track_2_should_be_there, self.player.song_list)
+        self.assertNotIn(track_should_not_be_there, self.player.song_list)
+        self.assertEquals(self.player.current_track_idx, 1)