trackdb: Add special Tags for user-controlled playlists

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

trackdb/test_user.py

@@ -0,0 +1,74 @@
+# Copyright 2021 (c) Anna Schumaker.
+from lib import fake
+from lib import tag
+from lib import tagstore
+from . import user
+import unittest
+
+class TestUserTags(unittest.TestCase):
+    def test_collection_tag(self):
+        c = user.CollectionTag()
+        self.assertIsInstance(c, tag.Tag)
+        self.assertTrue(c.loop)
+        self.assertFalse(c.can_loop())
+
+    def test_new_tracks_tag(self):
+        n = user.NewTracksTag()
+        self.assertIsInstance(n, tag.Tag)
+        self.assertTrue(n.can_loop())
+        self.assertTrue(n.can_random())
+
+        n.tracks = [ fake.Track(1), fake.Track(2), fake.Track(3) ]
+        state = n.__getstate__()
+        self.assertEqual(state["name"], "New Tracks")
+        self.assertEqual(state["sort"], "new tracks")
+        self.assertEqual(state["current"], -1)
+        self.assertEqual(state["tracks"], [ ])
+        self.assertFalse(state["loop"])
+        self.assertFalse(state["random"])
+
+    def test_previous_tag(self):
+        p = user.PreviousTag()
+        self.assertIsInstance(p, tag.Tag)
+        self.assertFalse(p.can_loop())
+        self.assertFalse(p.can_random())
+
+        p.add_track(fake.Track(1))
+        self.assertEqual(p.tracks, [ fake.Track(1) ])
+        self.assertIsNone(p.next())
+
+        p.add_track(fake.Track(2))
+        self.assertEqual(p.tracks, [ fake.Track(2), fake.Track(1) ])
+        self.assertEqual(p.next(), fake.Track(1))
+
+        p.add_track(fake.Track(3))
+        self.assertEqual(p.tracks, [ fake.Track(3), fake.Track(2), fake.Track(1) ])
+        self.assertEqual(p.next(), fake.Track(2))
+        self.assertEqual(p.next(), fake.Track(1))
+
+        state = p.__getstate__()
+        self.assertEqual(state["name"], "Previous")
+        self.assertEqual(state["sort"], "previous")
+        self.assertEqual(state["current"], 2)
+        self.assertEqual(state["tracks"], [ ])
+        self.assertFalse(state["loop"])
+        self.assertFalse(state["random"])
+
+    def test_up_next_tag(self):
+        u = user.UpNextTag()
+        self.assertIsInstance(u, tag.Tag)
+        self.assertFalse(u.loop)
+        self.assertFalse(u.can_loop())
+        self.assertIsNone(u.next())
+
+        u.tracks = [ fake.Track(1), fake.Track(2), fake.Track(3) ]
+        self.assertEqual(u.next(), fake.Track(1))
+        self.assertEqual(u.tracks, [ fake.Track(2), fake.Track(3) ])
+
+        self.assertEqual(u.next(), fake.Track(2))
+        self.assertEqual(u.tracks, [ fake.Track(3) ])
+
+        u.random = True
+        self.assertEqual(u.next(), fake.Track(3))
+        self.assertEqual(u.tracks, [ ])
+        self.assertFalse(u.random)

trackdb/user.py

@@ -0,0 +1,56 @@
+# Copyright 2021 (c) Anna Schumaker.
+from lib import tag
+from lib import tagstore
+
+class CollectionTag(tag.Tag):
+    def __init__(self):
+        tag.Tag.__init__(self, "Collection")
+        self.loop = True
+
+    def can_loop(self): return False
+
+
+class NewTracksTag(tag.Tag):
+    def __init__(self):
+        tag.Tag.__init__(self, "New Tracks")
+
+    def __getstate__(self):
+        state = super().__getstate__()
+        state["tracks"].clear()
+        return state
+
+
+class PreviousTag(tag.Tag):
+    def __init__(self):
+        tag.Tag.__init__(self, "Previous")
+
+    def __getstate__(self):
+        state = super().__getstate__()
+        state["tracks"].clear()
+        return state
+
+    def can_random(self): return False
+    def can_loop(self): return False
+
+    def add_track(self, track):
+        with self.lock:
+            self.tracks.insert(0, track)
+            self.current = 0
+        self.TrackAdded.publish(self, track, 0)
+
+
+class UpNextTag(tag.Tag):
+    def __init__(self):
+        tag.Tag.__init__(self, "Up Next")
+
+    def can_loop(self): return False
+
+    def next(self):
+        track = super().next()
+        if track is not None:
+            self.remove_track(track)
+        with self.lock:
+            self.current -= 1
+            if len(self.tracks) == 0:
+                self.random = False
+        return track