« get me outta code hell

data: Track.withAlbum: refactor for clarity - hsmusic-wiki - HSMusic - static wiki software cataloguing collaborative creation
about summary refs log tree commit diff
diff options
context:
space:
mode:
author(quasar) nebula <qznebula@protonmail.com>2023-10-26 19:09:22 -0300
committer(quasar) nebula <qznebula@protonmail.com>2023-10-26 19:37:06 -0300
commitbb646f28853399a43d52a056c86d04f6a4343932 (patch)
treeb23771363b4e892318b0a8681822454510c4a682
parent5f740046562c85ab4e00063037ddf3af5a545279 (diff)
data: Track.withAlbum: refactor for clarity
Utilizes availability checks instead of manual null comparisons and
empty() calls, extracts track lists using withPropertyFromList,
operates on index instead of unique album object where possible
(including found / not found check).
-rw-r--r--src/data/composite/things/track/withAlbum.js98
1 files changed, 71 insertions, 27 deletions
diff --git a/src/data/composite/things/track/withAlbum.js b/src/data/composite/things/track/withAlbum.js
index 0e85cee9..9c974cd1 100644
--- a/src/data/composite/things/track/withAlbum.js
+++ b/src/data/composite/things/track/withAlbum.js
@@ -4,9 +4,12 @@
 // exit instead.
 
 import {input, templateCompositeFrom} from '#composite';
-import {empty} from '#sugar';
 import {is} from '#validators';
 
+import {exitWithoutDependency, withResultOfAvailabilityCheck}
+  from '#composite/control-flow';
+import {withPropertyFromList} from '#composite/data';
+
 export default templateCompositeFrom({
   annotation: `withAlbum`,
 
@@ -20,43 +23,84 @@ export default templateCompositeFrom({
   outputs: ['#album'],
 
   steps: () => [
+    // null albumData is always an early exit.
+
+    exitWithoutDependency({
+      dependency: 'albumData',
+      mode: input.value('null'),
+    }),
+
+    // empty albumData conditionally exits early or outputs null.
+
+    withResultOfAvailabilityCheck({
+      from: 'albumData',
+      mode: input.value('empty'),
+    }).outputs({
+      '#availability': '#albumDataAvailability',
+    }),
+
     {
-      dependencies: [input('notFoundMode'), 'albumData'],
-      compute: (continuation, {
+      dependencies: [input('notFoundMode'), '#albumDataAvailability'],
+      compute(continuation, {
         [input('notFoundMode')]: notFoundMode,
-        ['albumData']: albumData,
-      }) =>
-        (albumData === null
-          ? continuation.exit(null)
-       : empty(albumData)
-          ? (notFoundMode === 'exit'
-              ? continuation.exit(null)
-              : continuation.raiseOutput({'#album': null}))
-          : continuation()),
+        ['#albumDataAvailability']: albumDataIsAvailable,
+      }) {
+        if (albumDataIsAvailable) return continuation();
+        switch (notFoundMode) {
+          case 'exit': return continuation.exit(null);
+          case 'null': return continuation.raiseOutput({'#album': null});
+        }
+      },
     },
 
+    withPropertyFromList({
+      list: 'albumData',
+      property: input.value('tracks'),
+    }),
+
     {
-      dependencies: [input.myself(), 'albumData'],
+      dependencies: [input.myself(), '#albumData.tracks'],
       compute: (continuation, {
         [input.myself()]: track,
-        ['albumData']: albumData,
-      }) =>
-        continuation({
-          ['#album']:
-            albumData.find(album => album.tracks.includes(track))
-              ?? null,
-        }),
+        ['#albumData.tracks']: trackLists,
+      }) => continuation({
+        ['#albumIndex']:
+          trackLists.findIndex(tracks => tracks.includes(track)),
+      }),
     },
 
+    // album not found conditionally exits or outputs null.
+
+    withResultOfAvailabilityCheck({
+      from: '#albumIndex',
+      mode: input.value('index'),
+    }).outputs({
+      '#availability': '#albumAvailability',
+    }),
+
     {
-      dependencies: [input('notFoundMode'), '#album'],
-      compute: (continuation, {
+      dependencies: [input('notFoundMode'), '#albumAvailability'],
+      compute(continuation, {
         [input('notFoundMode')]: notFoundMode,
-        ['#album']: album,
-      }) =>
-        ((album === null && notFoundMode === 'exit')
-          ? continuation.exit(null)
-          : continuation.raiseOutput({'#album': album})),
+        ['#albumAvailability']: albumIsAvailable,
+      }) {
+        if (albumIsAvailable) return continuation();
+        switch (notFoundMode) {
+          case 'exit': return continuation.exit(null);
+          case 'null': return continuation.raiseOutput({'#album': null});
+        }
+      },
+    },
+
+    {
+      dependencies: ['albumData', '#albumIndex'],
+      compute: (continuation, {
+        ['albumData']: albumData,
+        ['#albumIndex']: albumIndex,
+      }) => continuation.raiseOutput({
+        ['#album']:
+          albumData[albumIndex],
+      }),
     },
   ],
 });