trackdb: Give the TagStack a NextTrack publisher

This is mostly needed so we save the stack after tracks are picked,
otherwise queued tracks will keep reappearing after a restart.

Signed-off-by: Anna Schumaker <Anna@NoWheyCreamery.com>

test_trackdb.py

@@ -106,6 +106,7 @@ class TestTrackDB(unittest.TestCase):
         self.assertIn(trackdb.save, trackdb.tags.User.Added.subscribers)
         self.assertIn(trackdb.save, trackdb.tags.User.Removed.subscribers)
         self.assertIn(trackdb.save, trackdb.Stack.PushPop.subscribers)
+        self.assertIn(trackdb.save, trackdb.Stack.NextTrack.subscribers)
 
     def test_trackdb_save_load(self):
         db_file = lib.data.DataFile(trackdb.File, lib.data.READ)

trackdb/__init__.py

@@ -92,6 +92,7 @@ def __register_callbacks():
         store.Removed.register(save)
     Tracks.Updated.register(save)
     Stack.PushPop.register(save)
+    Stack.NextTrack.register(save)
 __register_callbacks()
 
 def reset():

trackdb/stack.py

@@ -8,6 +8,7 @@ class TagStack:
         self.tags = [ ]
         self.Counter = counter.Counter(-1, 99)
         self.PushPop = publisher.Publisher()
+        self.NextTrack = publisher.Publisher()
 
     def __do_next__(self, tag):
         if track := tag.next():
@@ -21,6 +22,7 @@ class TagStack:
         self.__dict__.update(state)
         self.Counter = counter.Counter(-1, 99)
         self.PushPop = publisher.Publisher()
+        self.NextTrack = publisher.Publisher()
 
     def current(self):
         if len(self.tags) == 0:
@@ -38,6 +40,7 @@ class TagStack:
     def next(self):
         ret = self.__next_track__()
         count = self.Counter.decrement()
+        self.NextTrack.publish(ret)
         return (ret, count != -1)
 
     def pop(self):

trackdb/test_stack.py

@@ -20,10 +20,14 @@ class FakeTrack:
 class TestTagStack(unittest.TestCase):
     def setUp(self):
         self.pushpop = None
+        self.next_track = None
 
     def tearDown(self):
         tags.reset()
 
+    def on_next_track(self, track):
+        self.next_track = track
+
     def on_push_pop(self, prev, new):
         self.pushpop = (prev, new)
 
@@ -31,11 +35,13 @@ class TestTagStack(unittest.TestCase):
         s = stack.TagStack()
         self.assertIsInstance(s.Counter, counter.Counter)
         self.assertIsInstance(s.PushPop, publisher.Publisher)
+        self.assertIsInstance(s.NextTrack, publisher.Publisher)
         self.assertEqual(s.tags, [ ])
 
     def test_tag_stack_next(self):
         s = stack.TagStack()
         t = tag.Tag("Test")
+        s.NextTrack.register(self.on_next_track)
         s.push(t)
 
         t.tracks = [ FakeTrack(1), FakeTrack(2), FakeTrack(3) ]
@@ -43,22 +49,27 @@ class TestTagStack(unittest.TestCase):
 
         (res, cont) = s.next()
         self.assertEqual( (res.n, cont), (1, True) )
+        self.assertEqual(self.next_track.n, 1)
         self.assertEqual(s.tags, [ t ])
 
         (res, cont) = s.next()
         self.assertEqual( (res.n, cont), (2, True) )
+        self.assertEqual(self.next_track.n, 2)
         self.assertEqual(s.tags, [ t ])
 
         (res, cont) = s.next()
         self.assertEqual( (res.n, cont), (3, True) )
+        self.assertEqual(self.next_track.n, 3)
         self.assertEqual(s.tags, [ t ])
 
         (res, cont) = s.next()
         self.assertEqual( (res.n, cont), (4, True) )
+        self.assertEqual(self.next_track.n, 4)
         self.assertEqual(s.tags, [ ])
 
         (res, cont) = s.next()
         self.assertEqual( (res.n, cont), (5, True) )
+        self.assertEqual(self.next_track.n, 5)
 
         self.assertEqual([ t.n for t in tags.User["Previous"].tracks ],
                          [ 5, 4, 3, 2, 1 ])
@@ -163,10 +174,13 @@ class TestTagStack(unittest.TestCase):
         self.assertEqual(s.tags, [ t ])
         self.assertIsInstance(s.Counter, counter.Counter)
         self.assertIsInstance(s.PushPop, publisher.Publisher)
+        self.assertIsInstance(s.NextTrack, publisher.Publisher)
 
         s.PushPop.register(self.on_push_pop)
+        s.PushPop.register(self.on_next_track)
         s.count = 3
         s.reset()
         self.assertEqual(s.tags, [ ])
         self.assertIsInstance(s.Counter, counter.Counter)
         self.assertEqual(len(s.PushPop.subscribers), 0)
+        self.assertEqual(len(s.NextTrack.subscribers), 0)