discombobulator 1.0.0

package/src/test/articulation.mjs

@@ -0,0 +1,66 @@
+// articulation.mjs
+//
+// Tests for articulation.mjs.
+
+import { expect } from './testing.mjs'
+
+import { Element } from '../element.mjs'
+import { Articulation } from '../articulation.mjs'
+
+export const test = {
+  tests: [ 
+    {
+      title: "default constructor results in undefined symbol",
+      test: () => {
+        const articulation = new Articulation();
+
+        expect(articulation.symbol, undefined);
+      },
+    },
+    {
+      title: "constructor correctly initialises valid symbol",
+      test: () => {
+        const articulation = new Articulation("test");
+        const symbol = Symbol.for("test");
+
+        expect(articulation.symbol, (result) => { return result === symbol; });
+      },
+    },
+    
+    {
+      title: "isEqual succeeds when comparing with self",
+      test: () => {
+        const articulation = new Articulation("test");
+
+        expect(articulation.isEqual(articulation), true);
+      },
+    },
+    {
+      title: "isEqual succeeds when comparing articulations with the same symbol",
+      test: () => {
+        const articulation = new Articulation("test");
+        const other = new Articulation("test");
+
+        expect(articulation.isEqual(other), true);
+      },
+    },
+    {
+      title: "isEqual fails when comparing articulations with different symbols",
+      test: () => {
+        const articulation = new Articulation("test");
+        const other = new Articulation("other");
+
+        expect(articulation.isEqual(other), false);
+      },
+    },
+    {
+      title: "isEqual fails when comparing against a non-articulation class",
+      test: () => {
+        const articulation = new Articulation();
+        const other = new Element();
+
+        expect(articulation.isEqual(other), false);
+      },
+    },
+  ],
+}

package/src/test/articulationset.mjs

@@ -0,0 +1,43 @@
+// articulationset.mjs
+//
+// Tests for articulationset.mjs.
+
+import { expect, expectException } from './testing.mjs'
+
+import { Instruments } from '../instrument.mjs'
+import { Articulations } from '../articulation.mjs'
+import { ArticulationSet } from '../articulationset.mjs'
+
+export const test = {
+  tests: [ 
+    {
+      title: "default constructor results in correct set",
+      test: () => {
+        let set = new ArticulationSet();
+
+        expect(set.isAbstract, false);
+        expect(set.allowDuplicates, false);
+        expect(set.size, 0);
+      },
+    },
+    {
+      title: "add throws error when adding non-articulation",
+      test: () => {
+        let set = new ArticulationSet();
+        let element = Instruments.Snare;
+
+        expectException(() => { set.add(element); }, Error);
+      },
+    },
+    {
+      title: "add succeeds adding articulation",
+      test: () => {
+        let set = new ArticulationSet();
+        let element = Articulations.Accent;
+
+        expect(set.add(element), (result) => { return result === set; });
+      },
+    },
+
+  ],
+}

package/src/test/binaryoperator.mjs

@@ -0,0 +1,210 @@
+// operator.mjs
+//
+// Tests for operator.mjs.
+
+import { expect, expectException } from "./testing.mjs";
+
+import { Set } from "../set.mjs";
+import { Instruments } from "../instrument.mjs";
+import { InstrumentSet } from "../instrumentset.mjs";
+import { ArticulationSet } from "../articulationset.mjs";
+
+export const test = {
+  tests: [
+    {
+      title: "default constructor results in correct set",
+      test: () => {
+        expectException(() => {
+          new Set.BinaryOperator();
+        }, Error);
+      },
+    },
+    {
+      title: "constructor results in Error exception when first set undefined",
+      test: () => {
+        expectException(() => {
+          new Set.BinaryOperator(undefined, new Set());
+        }, Error);
+      },
+    },
+    {
+      title: "constructor results in Error exception when second set undefined",
+      test: () => {
+        expectException(() => {
+          new Set.BinaryOperator(new Set(), undefined);
+        }, Error);
+      },
+    },
+    {
+      title:
+        "constructor throws Error when sets are different types without validation skipping",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new ArticulationSet();
+
+        expectException(() => {
+          new Set.BinaryOperator(set1, set2, {
+            skipValidation: false,
+          });
+        }, Error);
+      },
+    },
+    {
+      title:
+        "constructor succeeds when sets are different types with validation skipping",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new ArticulationSet();
+
+        const operator = new Set.BinaryOperator(set1, set2, {
+          skipValidation: true,
+        });
+
+        expect(operator.elements[0] === set1, true);
+        expect(operator.elements[1] === set2, true);
+        expect(operator.isAbstract, true);
+        expect(operator.allowDuplicates, false);
+      },
+    },
+{
+      title:
+        "constructor succeeds when sets are same types without validation skipping",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        const operator = new Set.BinaryOperator(set1, set2, {
+          skipValidation: false,
+        });
+
+        expect(operator.elements[0] === set1, true);
+        expect(operator.elements[1] === set2, true);
+      },
+    },
+    {
+      title:
+        "constructor succeeds when sets are same types with validation skipping",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        const operator = new Set.BinaryOperator(set1, set2, { skipValidation: true });
+
+        expect(operator.elements[0] === set1, true);
+        expect(operator.elements[1] === set2, true);
+      },
+    },
+
+    {
+      title:
+        "smallestSet returns smallest set when smallest is first",
+      test: () => {
+        const set1 = new InstrumentSet({ add: Instruments.Snare });
+        const set2 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ]});
+
+        const operator = new Set.BinaryOperator(set1, set2);
+
+        expect(operator.smallestSet, 0);
+      },
+    },
+    {
+      title:
+        "smallestSet returns smallest set when smallest is second",
+      test: () => {
+        const set1 = new InstrumentSet({ add: [ Instruments.Snare, Instruments.Bass1 ] });
+        const set2 = new InstrumentSet({ add: Instruments.Snare});
+
+        const operator = new Set.BinaryOperator(set1, set2);
+
+        expect(operator.smallestSet, 1);
+      },
+    },
+    {
+      title:
+        "smallestSet returns smallest set when both are the same size",
+      test: () => {
+        const set1 = new InstrumentSet({ add: Instruments.Bass1 });
+        const set2 = new InstrumentSet({ add: Instruments.Snare});
+
+        const operator = new Set.BinaryOperator(set1, set2);
+
+        expect(operator.smallestSet, 0);
+      },
+    },
+
+    {
+      title:
+        "size throws error (Operator not derived)",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        const operator = new Set.BinaryOperator(set1, set2);
+
+        expectException(() => operator.size, Error);
+      },
+    },
+
+    {
+      title:
+        "elementAt throws error because size throws",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        const operator = new Set.BinaryOperator(set1, set2);
+
+        expectException(() => operator.elementAt(0), Error);
+      },
+    },
+
+    {
+      title:
+        "has throws error (Operator not derived)",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        const operator = new Set.BinaryOperator(set1, set2);
+
+        expectException(() => operator.has(), Error);
+      },
+    },
+
+    {
+      title: "clone succeeds on an operator (Shallow)",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        const operator = new Set.BinaryOperator(set1, set2);
+        const clone = operator.clone();
+
+        expect(clone.isAbstract, true);
+        expect(clone.allowDuplicates, false);
+        expect(clone.isStrict, true);
+        expect(clone.skipValidation, false);
+        expect(clone.elements[0] === set1, true);
+        expect(clone.elements[1] === set2, true);
+      },
+    },
+    {
+      title: "clone succeeds on an operator (Deep)",
+      test: () => {
+        const set1 = new InstrumentSet();
+        const set2 = new InstrumentSet();
+
+        const operator = new Set.BinaryOperator(set1, set2);
+        const clone = operator.clone(true);
+
+        expect(clone.isAbstract, true);
+        expect(clone.allowDuplicates, false);
+        expect(clone.isStrict, true);
+        expect(clone.skipValidation, false);
+        expect(clone.elements[0] !== set1, true);
+        expect(clone.elements[1] !== set2, true);
+      },
+    },
+
+  ],
+};

package/src/test/chord.mjs

@@ -0,0 +1,292 @@
+// chord.mjs
+//
+// Tests for chord.mjs.
+
+import { expect, expectException } from "./testing.mjs";
+
+import { Instruments } from "../instrument.mjs";
+import { Articulations } from "../articulation.mjs";
+import { ArticulationSet } from "../articulationset.mjs";
+import { Chord } from "../chord.mjs";
+import { Note } from "../note.mjs";
+import { NoteSet } from "../noteset.mjs";
+import { Group } from "../group.mjs";
+
+export const test = {
+  tests: [
+    {
+      title: "default constructor results in correct chord",
+      test: () => {
+        let chord = new Chord();
+
+        expect(chord.isAbstract, false);
+        expect(chord.allowDuplicates, false);
+        expect(chord.size, 0);
+      },
+    },
+    {
+      title: "add throws error when adding non-note",
+      test: () => {
+        let chord = new Chord();
+        let element = new Group(1, 1);
+
+        expectException(() => {
+          chord.add(element);
+        }, Error);
+      },
+    },
+    {
+      title: "add succeeds adding note",
+      test: () => {
+        let chord = new Chord();
+        let element = new Note();
+
+        expect(chord.add(element), (result) => {
+          return result === chord;
+        });
+      },
+    },
+
+    {
+      title:
+        "isEqual fails when compared with chord with different numbers of notes",
+      test: () => {
+        const chord = new Chord({ add: [Instruments.Snare] });
+        const other = new Chord({ add: [Instruments.Snare, Instruments.Bass1] });
+
+        expect(chord.isEqual(other), false);
+      },
+    },
+    {
+      title:
+        "isEqual fails when compared with chord with different numbers of articulations",
+      test: () => {
+        const chord = new Chord({
+          add: [new Note({ add: [Instruments.Snare, Articulations.Accent] })],
+        });
+        const other = new Chord({ add: [Instruments.Snare] });
+
+        expect(chord.isEqual(other), false);
+      },
+    },
+    {
+      title:
+        "isEqual succeeds when comparing chords with same instruments (no articulations)",
+      test: () => {
+        const chord = new Chord({ add: [Instruments.Snare, Instruments.Bass1] });
+        const other = new Chord({add: [Instruments.Snare, Instruments.Bass1],});
+
+        expect(chord.isEqual(other), true);
+      },
+    },
+    {
+      title:
+        "isEqual succeeds when comparing chords with same, but disordered instruments (no articulations)",
+      test: () => {
+        const chord = new Chord({ add: [Instruments.Bass1, Instruments.Snare] });
+        const other = new Chord({add: [Instruments.Snare, Instruments.Bass1],});
+
+        expect(chord.isEqual(other), true);
+      },
+    },
+    {
+      title:
+        "isEqual succeeds when comparing chords with same instruments and articulations (ordered)",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Accent] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Fermata] }),
+          ],
+        });
+        const other = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Accent] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Fermata] }),
+          ],
+        });
+
+        expect(chord.isEqual(other), true);
+      },
+    },
+    {
+      title:
+        "isEqual succeeds when comparing chords with same instruments and articulations (disordered)",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Fermata] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Accent] }),
+          ],
+        });
+        const other = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Accent] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Fermata] }),
+          ],
+        });
+
+        expect(chord.isEqual(other), true);
+      },
+    },
+    {
+      title:
+        "isEqual fails when comparing chords with different instruments (no articulations)",
+      test: () => {
+        const chord = new Chord({ add: [Instruments.Bass1, Instruments.Snare] });
+        const other = new Chord({add: [Instruments.Snare, Instruments.Claves],});
+
+        expect(chord.isEqual(other), false);
+      },
+    },
+    {
+      title:
+        "isEqual fails when comparing chords with different instruments (same articulations)",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Fermata] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Accent] }),
+          ],
+        });
+        const other = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Accent] }),
+            new Note({ add: [Instruments.Claves, Articulations.Fermata] }),
+          ],
+        });
+
+        expect(chord.isEqual(other), false);
+      },
+    },
+    {
+      title:
+        "isEqual fails when comparing chords with different instruments (different articulations)",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Fermata] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Accent] }),
+          ],
+        });
+        const other = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Staccato] }),
+            new Note({ add: [Instruments.Claves, Articulations.Fermata] }),
+          ],
+        });
+
+        expect(chord.isEqual(other), false);
+      },
+    },
+    {
+      title:
+        "isEqual fails when comparing chords with same instruments (different articulations)",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Fermata] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Accent] }),
+          ],
+        });
+        const other = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Staccato] }),
+            new Note({ add: [Instruments.Bass1, Articulations.Fermata] }),
+          ],
+        });
+
+        expect(chord.isEqual(other), false);
+      },
+    },
+
+    {
+      title:
+        "internalAdd correctly merges notes",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Fermata] }),
+          ],
+        });
+        const note = new Note({ 
+          add: [
+            Instruments.Snare, 
+            new ArticulationSet({add: [ Articulations.Staccato, Articulations.Accent ]})
+          ] 
+        });
+
+        chord.internalAdd(note);
+
+        expect(chord.size, 1);
+        expect(chord.elementAt(0).instrument === Instruments.Snare, true);
+        const articulations = chord.elementAt(0).articulations;
+        expect(articulations !== undefined, true);
+        expect(articulations.elementAt(0) === Articulations.Fermata, true);
+        expect(articulations.elementAt(1) === Articulations.Staccato, true);
+        expect(articulations.elementAt(2) === Articulations.Accent, true);
+      },
+    },
+    {
+      title:
+        "internalAdd correctly adds notes with different instruments",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Fermata] }),
+          ],
+        });
+        const note = new Note({ 
+          add: [
+            Instruments.Bass1, 
+            new ArticulationSet({add: [ Articulations.Staccato, Articulations.Accent ]})
+          ] 
+        });
+
+        chord.internalAdd(note);
+
+        expect(chord.size, 2);
+        expect(chord.elementAt(0).instrument === Instruments.Snare, true);
+        expect(chord.elementAt(1).instrument === Instruments.Bass1, true);
+        expect(chord.elementAt(0).articulations !== undefined, true);
+        expect(chord.elementAt(0).articulations.elementAt(0) === Articulations.Fermata, true);
+        const articulations = chord.elementAt(1).articulations;
+        expect(articulations !== undefined, true);
+        expect(articulations.elementAt(0) === Articulations.Staccato, true);
+        expect(articulations.elementAt(1) === Articulations.Accent, true);
+      },
+    },
+
+    {
+      title:
+        "toNoteSet correctly returns equivalent note chord",
+      test: () => {
+        const chord = new Chord({
+          add: [
+            new Note({ add: [Instruments.Snare, Articulations.Fermata] }),
+            new Note({
+              add: [
+                Instruments.Bass1, 
+                new ArticulationSet({add: [ Articulations.Staccato, Articulations.Accent ]})
+              ] 
+            })
+          ],
+        });
+
+        const noteset = chord.toNoteSet();
+
+        expect(noteset instanceof NoteSet, true);
+        expect(noteset.size, 2);
+        expect(noteset.elementAt(0).instrument === Instruments.Snare, true);
+        expect(noteset.elementAt(1).instrument === Instruments.Bass1, true);
+        expect(noteset.elementAt(0).articulations !== undefined, true);
+        expect(noteset.elementAt(0).articulations.elementAt(0) === Articulations.Fermata, true);
+        const articulations = noteset.elementAt(1).articulations;
+        expect(articulations !== undefined, true);
+        expect(articulations.elementAt(0) === Articulations.Staccato, true);
+        expect(articulations.elementAt(1) === Articulations.Accent, true);
+      },
+    },
+
+  ],
+};

package/src/test/concolour.mjs

@@ -0,0 +1,70 @@
+// concolour.mjs
+//
+// Console and console text colour..
+
+const timestamp = () => { 
+  const now = new Date(); 
+  return `${now.toLocaleDateString()} ${now.toLocaleTimeString()}`; 
+};
+
+export default {
+  reset: "\x1b[0m",
+  bright: "\x1b[1m",
+  dim: "\x1b[2m",
+  underscore: "\x1b[4m",
+  blink: "\x1b[5m",
+  reverse: "\x1b[7m",
+  hidden: "\x1b[8m",
+  
+  fg: {
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m",
+    brightred: "\x1b[91m",
+    brightgreen: "\x1b[92m",
+    brightyellow: "\x1b[93m",
+    brightblue: "\x1b[94m",
+    brightmagenta: "\x1b[95m",
+    brightcyan: "\x1b[96m",
+    brightwhite: "\x1b[97m",
+  },
+  
+  bg: {
+    black: "\x1b[40m",
+    red: "\x1b[41m",
+    green: "\x1b[42m",
+    yellow: "\x1b[43m",
+    blue: "\x1b[44m",
+    magenta: "\x1b[45m",
+    cyan: "\x1b[46m",
+    white: "\x1b[47m",
+    gray: "\x1b[100m",
+    brightred: "\x1b[101m",
+    brightgreen: "\x1b[102m",
+    brightyellow: "\x1b[103m",
+    brightblue: "\x1b[104m",
+    brightmagenta: "\x1b[105m",
+    brightcyan: "\x1b[106m",
+    brightwhite: "\x1b[107m",
+  },
+
+  log: function(message, colour = this.fg.white, bgcolour = "", options = {}) {
+    if (options.suffix) {
+      process.stdout.write(`${colour}${bgcolour}${message}${this.reset}\n`);
+    } else {
+      const output = `${colour}${bgcolour}[${timestamp()}] ${message}${this.reset}`;
+
+      if (options.prefix) {
+        process.stdout.write(output); 
+      } else {
+        console.log(output); 
+      }
+    }
+  },
+}