trackdb: Give TagStacks an autopause counter

And change next() to return both a track and a boolean indicating if we
should keep playing

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

trackdb/stack.py

@@ -1,10 +1,12 @@
 # Copyright 2021 (c) Anna Schumaker.
+from lib import counter
 from lib import publisher
 from . import tags
 
 class TagStack:
     def __init__(self):
         self.tags = [ ]
+        self.Counter = counter.Counter(-1, 99)
         self.PushPop = publisher.Publisher()
 
     def __do_next__(self, tag):
@@ -17,6 +19,7 @@ class TagStack:
 
     def __setstate__(self, state):
         self.__dict__.update(state)
+        self.Counter = counter.Counter(-1, 99)
         self.PushPop = publisher.Publisher()
 
     def current(self):
@@ -24,13 +27,18 @@ class TagStack:
             return tags.User.store["Collection"]
         return self.tags[0]
 
-    def next(self):
+    def __next_track__(self):
         if len(self.tags) == 0:
             return self.__do_next__(tags.User["Collection"])
         if track := self.__do_next__(self.tags[0]):
             return track
         self.pop()
-        return self.next()
+        return self.__next_track__()
+
+    def next(self):
+        ret = self.__next_track__()
+        count = self.Counter.decrement()
+        return (ret, count != -1)
 
     def pop(self):
         prev = self.tags.pop(0)
@@ -60,4 +68,5 @@ class TagStack:
 
     def reset(self):
         self.tags.clear()
+        self.count = None
         self.PushPop.reset()

trackdb/test_stack.py

@@ -1,4 +1,5 @@
 # Copyright 2021 (c) Anna Schumaker.
+from lib import counter
 from lib import publisher
 from lib import tag
 from . import stack
@@ -28,6 +29,7 @@ class TestTagStack(unittest.TestCase):
 
     def test_tag_stack_init(self):
         s = stack.TagStack()
+        self.assertIsInstance(s.Counter, counter.Counter)
         self.assertIsInstance(s.PushPop, publisher.Publisher)
         self.assertEqual(s.tags, [ ])
 
@@ -39,19 +41,56 @@ class TestTagStack(unittest.TestCase):
         t.tracks = [ FakeTrack(1), FakeTrack(2), FakeTrack(3) ]
         tags.User["Collection"].tracks = [ FakeTrack(4), FakeTrack(5) ]
 
-        self.assertEqual(s.next().n, 1)
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (1, True) )
         self.assertEqual(s.tags, [ t ])
-        self.assertEqual(s.next().n, 2)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (2, True) )
         self.assertEqual(s.tags, [ t ])
-        self.assertEqual(s.next().n, 3)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (3, True) )
         self.assertEqual(s.tags, [ t ])
-        self.assertEqual(s.next().n, 4)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (4, True) )
         self.assertEqual(s.tags, [ ])
-        self.assertEqual(s.next().n, 5)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (5, True) )
 
         self.assertEqual([ t.n for t in tags.User["Previous"].tracks ],
                          [ 5, 4, 3, 2, 1 ])
 
+    def test_tag_stack_autopause(self):
+        s = stack.TagStack()
+        t = tag.Tag("Test")
+        s.push(t)
+
+        t.tracks = [ FakeTrack(1), FakeTrack(2), FakeTrack(3), FakeTrack(4) ]
+        s.Counter.set_value(2)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (1, True) )
+        self.assertEqual(s.tags, [ t ])
+        self.assertEqual(s.Counter.get_value(), 1)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (2, True) )
+        self.assertEqual(s.tags, [ t ])
+        self.assertEqual(s.Counter.get_value(), 0)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (3, False) )
+        self.assertEqual(s.tags, [ t ])
+        self.assertEqual(s.Counter.get_value(), -1)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (4, True) )
+        self.assertEqual(s.tags, [ t ])
+        self.assertEqual(s.Counter.get_value(), -1)
+
     def test_tag_stack_pop(self):
         s = stack.TagStack()
         t1 = tag.Tag("Test")
@@ -105,9 +144,10 @@ class TestTagStack(unittest.TestCase):
     def test_tag_stack_queue(self):
         s = stack.TagStack()
         s.queue(FakeTrack(1))
-
         self.assertEqual(s.tags, [ tags.User["Up Next"] ])
-        self.assertEqual(s.next().n, 1)
+
+        (res, cont) = s.next()
+        self.assertEqual( (res.n, cont), (1, True) )
         self.assertEqual(tags.User["Up Next"].tracks, [ ])
 
     def test_tag_stack_state(self):
@@ -121,9 +161,12 @@ class TestTagStack(unittest.TestCase):
         s.__dict__.clear()
         s.__setstate__(state)
         self.assertEqual(s.tags, [ t ])
+        self.assertIsInstance(s.Counter, counter.Counter)
         self.assertIsInstance(s.PushPop, publisher.Publisher)
 
         s.PushPop.register(self.on_push_pop)
+        s.count = 3
         s.reset()
         self.assertEqual(s.tags, [ ])
+        self.assertIsInstance(s.Counter, counter.Counter)
         self.assertEqual(len(s.PushPop.subscribers), 0)