discombobulator 1.0.1 → 1.0.2

package/src/test/regulargroupset.mjs

@@ -1,290 +0,0 @@
-// regulargroupset.mjs
-//
-// Tests for regulargroupset.mjs.
-
-import { expect, expectException } from './testing.mjs'
-
-import { RegularGroupSet } from '../regulargroupset.mjs'
-import { Instruments } from '../instrument.mjs'
-import { Group } from '../group.mjs'
-
-export const test = {
-  tests: [ 
-    {
-      title: "default constructor results in correct set",
-      test: () => {
-        let set = new RegularGroupSet();
-
-        expect(set.isAbstract, true);
-        expect(set.allowDuplicates, false);
-        expect(set.size, 1);
-        expect(set.start, 1);
-        expect(set.end, 1);
-        expect(set.step, 1);
-      },
-    },
-    {
-      title: "constructor throws error when start < 1",
-      test: () => {
-        let set;
-        
-        expectException(() => { set = new RegularGroupSet({ start: 0 }); }, Error);
-      },
-    },
-    {
-      title: `constructor throws error when start > ${Group.MAX_LENGTH}`,
-      test: () => {
-        let set;
-        
-        expectException(() => { set = new RegularGroupSet({ start: Group.MAX_LENGTH+1 }); }, Error);
-      },
-    },
-    {
-      title: `constructor succeeds when start in [1..${Group.MAX_LENGTH}]`,
-      test: () => {
-        let set;
-        
-        for (let value = 1; value <= Group.MAX_LENGTH; ++value) {
-          set = new RegularGroupSet({ start: value });
-          expect(set.start, value);
-        }
-      },
-    },
-    {
-      title: "constructor throws error when end < 1",
-      test: () => {
-        let set;
-        
-        expectException(() => { set = new RegularGroupSet({ end: 0 }); }, Error);
-      },
-    },
-    {
-      title: `constructor throws error when end > ${Group.MAX_LENGTH}`,
-      test: () => {
-        let set;
-        
-        expectException(() => { set = new RegularGroupSet({ end: Group.MAX_LENGTH+1 }); }, Error);
-      },
-    },
-    {
-      title: `constructor succeeds when end in [1..${Group.MAX_LENGTH}]`,
-      test: () => {
-        let set;
-        
-        for (let value = 1; value <= Group.MAX_LENGTH; ++value) {
-          set = new RegularGroupSet({ end: value });
-          expect(set.end, value);
-        }
-      },
-    },
-    {
-      title: `constructor throws error when end < start in [1..${Group.MAX_LENGTH-1}]`,
-      test: () => {
-        let set;
-        
-        for (let value = 1; value <= Group.MAX_LENGTH-1; ++value) {
-          expectException(() => { set = new RegularGroupSet({ start: value+1, end: value }); }, Error);
-        }
-      },
-    },
-    {
-      title: `constructor succeeds when end > start in [2..${Group.MAX_LENGTH}]`,
-      test: () => {
-        let set;
-        
-        for (let value = 2; value <= Group.MAX_LENGTH; ++value) {
-          set = new RegularGroupSet({ start: value-1, end: value });
-          expect(set.start, value-1);
-          expect(set.end, value);
-        }
-      },
-    },
-    {
-      title: "constructor throws error when step < 1",
-      test: () => {
-        let set;
-        
-        expectException(() => { set = new RegularGroupSet({ step: 0 }); }, Error);
-      },
-    },
-    {
-      title: `constructor throws error when step > ${Group.MAX_LENGTH}`,
-      test: () => {
-        let set;
-        
-        expectException(() => { set = new RegularGroupSet({ step: Group.MAX_LENGTH+1 }); }, Error);
-      },
-    },
-    {
-      title: `constructor succeeds when step in [1..${Group.MAX_LENGTH}]`,
-      test: () => {
-        let set;
-        
-        for (let value = 1; value <= Group.MAX_LENGTH; ++value) {
-          set = new RegularGroupSet({ step: value });
-          expect(set.step, value);
-        }
-      },
-    },
-
-    {
-      title: "clone correctly clones set",
-      test: () => {
-        const set = new RegularGroupSet({ start: 1, end: 2, step: 3 });
-        const clone = set.clone();
-        
-        expect(clone !== undefined, true);
-        expect(clone.start, 1);
-        expect(clone.end, 2);
-        expect(clone.step, 3);
-      },
-    },
-
-    {
-      title: `iterator correctly returns groups with step in [1..${Group.MAX_LENGTH}]`,
-      test: () => {
-        for (let step = 1; step <= Group.MAX_LENGTH; ++step) {
-          const set = new RegularGroupSet({ start: 1, end: Group.MAX_LENGTH, step: step });
-
-          expect(set.size, Math.ceil(Group.MAX_LENGTH / step));
-          
-          let length = 1;
-
-          for (let group of set) {
-            expect(group.length, length);
-
-            if (length < Group.MAX_LENGTH) {
-              expect(group.group, 0xffffffff & ((1 << length) - 1));
-            } else {
-              expect(group.group, 0xffffffff);
-            }
-
-            length += step;
-          }
-        }
-      },
-    },
-
-    {
-      title: "elementAt throws error for index < 0",
-      test: () => {
-        let set = new RegularGroupSet();
-
-        expectException(() => { set.elementAt(-1); }, Error);
-      },
-    },
-    {
-      title: "elementAt throws error for index higher than set size",
-      test: () => {
-        let set = new RegularGroupSet({ start: 1, end: 1, step: 1 });
-
-        expect(set.size, 1);
-
-        expectException(() => { set.elementAt(1); }, Error);
-      },
-    },
-    {
-      title: `elementAt correctly returns groups with step in [1..${Group.MAX_LENGTH}]`,
-      test: () => {
-        for (let step = 1; step <= Group.MAX_LENGTH; ++step) {
-          const set = new RegularGroupSet({ start: 1, end: Group.MAX_LENGTH, step: step });
-          const numGroups = Math.ceil(Group.MAX_LENGTH / step);
-
-          expect(set.size, numGroups);
-          
-          let length = 1;
-
-          for (let index = 0; index < numGroups; ++index) {
-            let group = set.elementAt(index);
-
-            expect(group.length, length);
-
-            if (length < Group.MAX_LENGTH) {
-              expect(group.group, 0xffffffff & ((1 << length) - 1));
-            } else {
-              expect(group.group, 0xffffffff);
-            }
-
-            length += step;
-          }
-        }
-      },
-    },
-
-    {
-      title: "has throws error when argument is undefined",
-      test: () => {
-        let set = new RegularGroupSet();
-
-        expectException(() => { set.has(); }, Error);
-      },
-    },
-    {
-      title: "has throws error when argument is not a group",
-      test: () => {
-        let set = new RegularGroupSet();
-
-        expectException(() => { set.has(Instruments.Snare); }, Error);
-      },
-    },
-    {
-      title: "has fails for group smaller than smallest in set",
-      test: () => {
-        let set = new RegularGroupSet({ start: 2, end: 2, step: 1});
-        let other = new Group(1, 1);
-
-        expect(set.has(other), false);
-      },
-    },
-    {
-      title: "has fails for group larger than largest in set",
-      test: () => {
-        let set = new RegularGroupSet({ start: 2, end: 2, step: 1});
-        let other = new Group(7, 3);
-
-        expect(set.has(other), false);
-      },
-    },
-    {
-      title: `has returns correct result for all length with step in [1..${Group.MAX_LENGTH}]`,
-      test: () => {
-        let set;
-        let other;
-        let length;
-
-        for (let step = 1; step <= Group.MAX_LENGTH; ++step) {
-          set = new RegularGroupSet({ start: 1, end: Group.MAX_LENGTH, step: step});
-
-          length = 1;
-
-          for (let group of set) {
-            while (length < group.length) {
-              other = new Group(0xffffffff, length);
-
-              expect(set.has(other), false);
-
-              ++length;
-            }
-
-            if (length === group.length) {
-              let other = new Group(0xffffffff, length);
-
-              expect(set.has(other), true);
-
-              ++length;
-            }
-          }
-
-          while (length <= Group.MAX_LENGTH) {
-            other = new Group(0xffffffff, length);
-
-            expect(set.has(other), false);
-
-            ++length;
-          }
-        }
-      },
-    },
-
-  ],
-}

package/src/test/repl.mjs

@@ -1,63 +0,0 @@
-// repl.mjs
-//
-// Script to initialise a repl context with exports from various modules
-// and enter the repl.
-
-(async (context, defs) => {
-  defs.forEach(async (def) => {
-    if (!Array.isArray(def)) {
-      def = [def];
-    }
-
-    if (def.length < 1)
-      throw new Error("Invalid import array - no module specified");
-
-    if (def.length < 2) def[1] = def[0][0].toUpperCase() + def[0].substring(1);
-
-    let module = def.shift();
-
-    def.forEach(async (key) => {
-      try {
-        context[key] = (await import(`../${module}.mjs`))[key];
-      } catch (e) {
-        console.log("OUCH");
-        context[key] = (await import(`./${module}.mjs`))[key];
-      }
-    });
-  });
-})((await import("repl")).start("disco>").context, [
-  // moduleName or [ moduleName, export1, export2, ... ]
-  //
-  // If only moduleName is provided, the exportName will be moduleName with
-  // the first letter capitalised.
-  //
-  // Will import moduleName and place export1, export2, etc in the repl context
-
-  ["instrument", "Instrument", "Instruments"],
-
-  ["element"],
-
-  ["articulation", "Articulation", "Articulations"],
-  ["group"],
-  ["set"],
-
-  ["instrumentset", "InstrumentSet"],
-  ["articulationset", "ArticulationSet"],
-
-  ["note"],
-
-  ["patternsource", "PatternSource"],
-  ["chord"],
-  ["noteset", "NoteSet"],
-  ["pattern"],
-  ["patternset", "PatternSet"],
-  ["groupset", "GroupSet"],
-  ["regulargroupset", "RegularGroupSet"],
-  ["irregulargroupset", "IrregularGroupSet"],
-  ["schedule"],
-  ["schema"],
-
-  // [ "factory" ],
-
-  ["replinit", "init"],
-]);

package/src/test/replinit.mjs

@@ -1,134 +0,0 @@
-// init.mjs
-//
-// Script to initialise a repl context with exports from various modules
-// and enter the repl.
-// import './disco.mjs'
-import { useDisco } from '../disco.mjs';
-
-import Fraction from 'fraction.js';
-
-import { Articulations } from '../articulation.mjs';
-import { ArticulationSet } from '../articulationset.mjs';
-import { Instruments } from '../instrument.mjs';
-import { InstrumentSet } from '../instrumentset.mjs';
-import { Note } from '../note.mjs';
-import { NoteSet } from '../noteset.mjs';
-import { Chord } from '../chord.mjs';
-import { Pattern } from '../pattern.mjs';
-import { PatternSet } from '../patternset.mjs';
-import { Schedule } from '../schedule.mjs';
-import { Schema } from '../schema.mjs';
-
-import { RegularGroupSet } from '../regulargroupset.mjs';
-import { IrregularGroupSet } from '../irregulargroupset.mjs';
-
-// Place any extra initialisation here...
-
-export function init() {
-  useDisco();
-  
-  // let A = new ArticulationSet();
-  // let B = new ArticulationSet();
-
-  // const a_articulations = [ 
-  //   Articulations.Accent, 
-  //   Articulations.Expressivo, 
-  //   Articulations.Marcato,
-  //   Articulations.Portato,
-  //   Articulations.Ghost,
-  // ];
-
-  // const b_articulations = [ 
-  //   Articulations.Staccato, 
-  //   Articulations.Expressivo, 
-  //   Articulations.Marcato,
-  //   Articulations.Tenuto,
-  // ];
-
-  // for (let a of a_articulations) {
-  //   A.add(a);
-  // }
-
-  // for (let b of b_articulations) {
-  //   B.add(b);
-  // }
-
-  // let D = A.union(B);
-
-  // return { A, B, D };
-
-  const instruments = [ Instruments.Snare, Instruments.Bass1, Instruments.HighHat ];
-  const instruments2 = [ Instruments.China, Instruments.Claves, Instruments.Crash ];
-
-  let P = new Pattern();
-
-  for (let instrument of instruments) {
-      let chord = new Chord();
-      chord.add(new Note({ add: instrument }));
-      P.add(chord); 
-  }
-
-  // let R = P.rotate({ rotateLeft: true });
-
-  // return { P, R };
-
-  let Q = new Pattern();
-
-  for (let instrument of instruments2) {
-      let chord = new NoteSet();
-      chord.add(new Note({ add: instrument }));
-      Q.add(chord);
-  }
-
-  let S = new PatternSet();
-  S.add(P).add(Q);
-
-  let T = new PatternSet();
-  T.add(Q);
-
-  // let X = new Schedule({ duration: new Fraction(1, 4), patterns: S });
-  // let Y = new Schedule({ duration: new Fraction(1, 8), patterns: T });
-
-  // let schema = new Schema();
-  // schema.add(X).add(Y);
-
-  return { P, Q, S, T };
-  // return { P, Q, S, T, X, Y, schema };
-
-  // let l = new Note(Instruments.Snare);
-  // let m = new Note(Instruments.Bass1);
-  // let n = new Note(Instruments.Snare, new ArticulationSet({ add: Articulations.Accent }));
-
-  // return { l, m, n };
-
-  // const instruments = [ Instruments.Snare, Instruments.Bass1, Instruments.HighHat ];
-  // const instruments2 = [ Instruments.China, Instruments.Claves, Instruments.Crash ];
-
-  // let P = new NoteSet();
-
-  // for (let instrument of instruments) {
-  //     P.add(new Note(instrument));
-  // }
-
-  // let Q = new NoteSet();
-
-  // for (let instrument of instruments2) {
-  //     Q.add(new Note(instrument));
-  // }
-
-  // return { P, Q };
-
-  // let A = new InstrumentSet();
-
-  // for (let instrument of instruments) {
-  //     A.add(instrument);
-  // }
-
-  // let B = new InstrumentSet();
-
-  // for (let instrument of instruments2) {
-  //     B.add(instrument);
-  // }
-
-  // return { A, B };
-}