feat(rivet): storyboard composition with flexible lengths and meters
Check and Windows preview / check (patina) (push) Successful in 3m59s
Check and Windows preview / check (rivet) (push) Successful in 2m2s
Check and Windows preview / previews (push) Successful in 1m8s
Independent plugin release / plan (push) Successful in 7s
Check and Windows preview / windows (push) Successful in 2m41s
Independent plugin release / build (push) Successful in 3m0s
Independent plugin release / publish (push) Successful in 9s

Rivet 0.4.0 tells a motif as a story. A timeline of blocks with roles
(statement, answer, departure, return, rest) replaces tasks, pins and
branches. Rivet writes each block from a motif and joins the seams with
a cut, breath, pickup or approach.

- Motifs of 1-8 bars in a bin of 16; storyboards up to 32 bars.
- Meters 2/4, 3/4, 4/4, 5/4, 6/8, 7/8 and 12/8 for import, writing,
  audition and export. Phrygian, harmonic minor and Mixolydian scales.
- Per-block options, Another take and Keep; templates for new boards.
- Editor rebuilt: motif bin, timeline, large piano roll, inspector,
  tabs for generation, harmony and sound roles, 32-step undo/redo.
- Sessions from 0.1-0.3 open as a storyboard from their source motif.
This commit is contained in:
nvrl committed 2026-11-06 02:15:18 +01:00
1 parent abd37fd4fe
commit f1366280ff
37 files changed
+3763 -2549

No files matched your search

-138
View File
@@ -1,138 +0,0 @@
use rivet_core::*;
fn session() -> Session {
let mut s = Session {
source: Some(demo_motif()),
..Default::default()
};
s.regenerate().unwrap();
s
}
#[test]
fn moves_fork_and_restore_context_without_losing_siblings() {
let mut s = session();
s.pin_selected(0).unwrap();
let root = s.save_branch("Original").unwrap();
let original = s.composed_phrase().unwrap();
s.apply_move(CreativeMove::Thin, Some(1)).unwrap();
let thin = s.active_branch.unwrap();
let thinned = s.composed_phrase().unwrap();
assert_ne!(thinned, original);
assert_eq!(
&thinned.notes[..demo_motif().notes.len()],
demo_motif().notes.as_slice()
);
s.restore_branch(root).unwrap();
assert_eq!(s.composed_phrase().unwrap(), original);
assert_eq!(s.pins.len(), 1);
s.apply_move(CreativeMove::Lengthen, Some(2)).unwrap();
let long = s.active_branch.unwrap();
assert_ne!(thin, long);
assert_eq!(s.branches.len(), 3);
assert_eq!(
s.branches.iter().find(|b| b.id == thin).unwrap().parent,
Some(root)
);
assert_eq!(
s.branches.iter().find(|b| b.id == long).unwrap().parent,
Some(root)
);
s.restore_branch(thin).unwrap();
assert_eq!(s.composed_phrase().unwrap(), thinned);
assert!(s.remove_branch(root).is_err());
assert_eq!(Session::from_json(&s.to_json().unwrap()).unwrap(), s);
}
#[test]
fn gesture_recall_and_cross_project_library_preserve_performance() {
let mut s = session();
s.performance.mode = RoleMode::CallResponse;
s.performance.voices[1].controller.enabled = true;
s.performance.voices[1].controller.cc = 20;
s.performance.voices[1].controller.shape(2);
let id = s.save_gesture("Floating answer", Some(1)).unwrap();
let saved = s.gestures[0].clone();
let bytes = s.export_gesture_library().unwrap();
let mut other = Session {
source: Some(demo_motif()),
harmony: Harmony::progression(2, Scale::Major),
..Default::default()
};
other.save_gesture("Existing", None).unwrap();
let context = other.harmony.clone();
other
.import_gesture_library(read_gesture_library(&bytes).unwrap())
.unwrap();
assert_eq!(other.gestures.len(), 2);
assert_ne!(other.gestures[0].id, other.gestures[1].id);
let imported = other.gestures[1].id;
other.recall_gesture(imported).unwrap();
assert_eq!(other.source, Some(saved.phrase));
assert_eq!(other.performance, saved.performance);
assert_eq!(other.harmony, context);
assert!(other.candidates.is_empty());
assert!(other.pins.is_empty());
assert!(s.gestures.iter().any(|g| g.id == id));
}
#[test]
fn blocked_moves_and_full_histories_are_atomic() {
let mut s = session();
s.settings.preserve_rhythm = true;
let before = s.clone();
assert!(s.apply_move(CreativeMove::Thin, None).is_err());
assert_eq!(s, before);
s.settings.preserve_rhythm = false;
for i in 0..MAX_BRANCHES {
s.save_branch(&format!("Idea {i}")).unwrap();
}
let before = s.clone();
assert!(s.apply_move(CreativeMove::Thin, Some(1)).is_err());
assert_eq!(s, before);
let leaf = s.active_branch.unwrap();
s.remove_branch(leaf).unwrap();
assert_eq!(s.branches.len(), MAX_BRANCHES - 1);
}
#[test]
fn malformed_ancestry_libraries_and_version_two_state_are_handled() {
let mut s = session();
let id = s.save_branch("Root").unwrap();
s.branches[0].parent = Some(id);
assert!(s.validate().is_err());
assert!(read_gesture_library(br#"{"version":99,"gestures":[]}"#).is_err());
let old = session();
let mut value = serde_json::to_value(&old).unwrap();
value["version"] = 2.into();
for key in [
"performance",
"gestures",
"branches",
"active_branch",
"next_id",
] {
value.as_object_mut().unwrap().remove(key);
}
let restored = Session::from_json(&serde_json::to_vec(&value).unwrap()).unwrap();
assert_eq!(restored.version, 3);
assert_eq!(restored.source, old.source);
assert_eq!(restored.performance, PerformanceSettings::default());
}
#[test]
fn delay_moves_adjacent_notes_together_and_rejects_protected_collisions() {
let mut s = session();
let make_note = |start| Note {
start,
duration: PPQ,
pitch: 60,
velocity: 90,
..Default::default()
};
s.candidates[s.selected].phrase.notes = vec![make_note(SECTION), make_note(SECTION + PPQ)];
s.apply_move(CreativeMove::Delay, Some(1)).unwrap();
let moved = s.composed_phrase().unwrap();
assert_eq!(moved.notes[0].start, SECTION + PPQ / 4);
assert_eq!(moved.notes[1].start, SECTION + PPQ + PPQ / 4);
s.candidates[0].phrase.notes[1].rhythm_locked = true;
let before = s.clone();
assert!(s.apply_move(CreativeMove::Delay, Some(1)).is_err());
assert_eq!(s, before);
}
+135 -160
View File
@@ -3,85 +3,110 @@ use rivet_core::*;
fn rhythm(p: &Phrase) -> Vec<(u32, u32)> {
p.notes.iter().map(|n| (n.start, n.duration)).collect()
}
fn options(motif: &Phrase, role: Role, s: &Settings) -> Vec<Candidate> {
realize(motif, role, 2, 2 * BAR, false, 0, s, &Harmony::default()).unwrap()
}
#[test]
fn alternatives_change_density_and_rhythm_instead_of_only_pitch() {
let source = demo_motif();
fn each_role_offers_distinct_reproducible_options_led_by_its_best_fit() {
let motif = demo_motif();
let s = Settings::default();
let candidates = generate(&source, &s).unwrap();
assert_eq!(candidates.len(), 3);
assert!(candidates
.iter()
.any(|c| c.phrase.notes.len() != source.notes.len() * 4));
assert!(candidates
.windows(2)
.any(|pair| rhythm(&pair[0].phrase) != rhythm(&pair[1].phrase)));
for c in &candidates {
assert_eq!(
&c.phrase.notes[..source.notes.len()],
source.notes.as_slice()
);
for (role, first) in [
(Role::Statement, Strategy::Quote),
(Role::Answer, Strategy::CallResponse),
(Role::Departure, Strategy::LaterPeak),
(Role::Return, Strategy::HarmonicReturn),
] {
let a = options(&motif, role, &s);
assert_eq!(a, options(&motif, role, &s), "{role:?} is deterministic");
assert_eq!(a.len(), 3, "{role:?}");
assert_eq!(a[0].strategy, first, "{role:?}");
for pair in a.windows(2) {
assert_ne!(pair[0].phrase, pair[1].phrase);
}
for c in &a {
c.phrase.validate(MAX_PLAYBACK_NOTES).unwrap();
assert_eq!(c.phrase.length, 2 * BAR);
}
}
assert_eq!(candidates, generate(&source, &s).unwrap());
let quote = &options(&motif, Role::Statement, &s)[0];
assert_eq!(
quote.phrase.notes, motif.notes,
"a statement quotes the motif"
);
let rest = realize(&motif, Role::Rest, 1, 0, false, 0, &s, &Harmony::default()).unwrap();
assert_eq!(rest.len(), 1);
assert!(rest[0].phrase.notes.is_empty());
}
#[test]
fn options_change_rhythm_and_density_not_only_pitch() {
let motif = demo_motif();
let s = Settings::default();
let mut signatures = std::collections::BTreeSet::new();
for seed in 0..12 {
for c in generate(&source, &Settings { seed, ..s.clone() }).unwrap() {
signatures.insert(rhythm(&c.phrase));
for role in [Role::Answer, Role::Departure] {
for c in options(&motif, role, &Settings { seed, ..s.clone() }) {
signatures.insert(rhythm(&c.phrase));
}
}
}
assert!(
signatures.len() > 3,
"seeds should explore multiple rhythmic decisions"
"seeds should explore rhythmic decisions"
);
assert!(options(&motif, Role::Answer, &s)
.iter()
.any(|c| c.phrase.notes.len() != motif.notes.len()));
}
#[test]
fn fixed_groove_and_separate_note_locks_take_priority() {
let mut source = demo_motif();
source.notes[1].pitch_locked = true;
source.notes[1].pitch = 99;
source.notes[3].rhythm_locked = true;
for c in generate(&source, &Settings::default()).unwrap() {
let pitch: Vec<_> = c.phrase.notes.iter().filter(|n| n.pitch_locked).collect();
assert_eq!(pitch.len(), 4);
assert!(pitch.iter().all(|n| n.pitch == 99));
for rep in 0..4 {
assert!(c.phrase.notes.iter().any(|n| n.rhythm_locked
&& n.start == source.notes[3].start + rep * source.length
&& n.duration == source.notes[3].duration));
let mut motif = demo_motif();
motif.notes[1].pitch_locked = true;
motif.notes[1].pitch = 99;
motif.notes[3].rhythm_locked = true;
for role in [Role::Answer, Role::Departure, Role::Return] {
for c in realize(
&motif,
role,
4,
0,
false,
0,
&Settings::default(),
&Harmony::default(),
)
.unwrap()
{
let locked: Vec<_> = c.phrase.notes.iter().filter(|n| n.pitch_locked).collect();
assert_eq!(locked.len(), 2, "{role:?} {:?}", c.strategy);
assert!(locked.iter().all(|n| n.pitch == 99));
for rep in 0..2 {
assert!(c.phrase.notes.iter().any(|n| n.rhythm_locked
&& n.start == motif.notes[3].start + rep * motif.length
&& n.duration == motif.notes[3].duration));
}
}
}
let source = demo_motif();
let repeated: Vec<_> = (0..4)
.flat_map(|rep| {
source
.notes
.iter()
.map(move |n| (n.start + rep * SECTION, n.duration))
})
.collect();
for c in generate(
&source,
&Settings {
preserve_rhythm: true,
..Settings::default()
},
)
.unwrap()
{
assert_eq!(rhythm(&c.phrase), repeated);
let motif = demo_motif();
let s = Settings {
preserve_rhythm: true,
..Settings::default()
};
for c in options(&motif, Role::Departure, &s) {
assert_eq!(rhythm(&c.phrase), rhythm(&motif));
}
}
#[test]
fn impossible_diversity_returns_one_honest_proposal() {
let mut source = demo_motif();
for n in &mut source.notes {
fn fully_locked_motif_returns_one_honest_option() {
let mut motif = demo_motif();
for n in &mut motif.notes {
n.locked = true;
}
let candidates = generate(&source, &Settings::default()).unwrap();
assert_eq!(candidates.len(), 1);
assert_eq!(candidates[0].phrase.notes.len(), source.notes.len() * 4);
let all = options(&motif, Role::Answer, &Settings::default());
assert_eq!(all.len(), 1);
assert_eq!(all[0].phrase.notes, motif.notes);
}
#[test]
fn harmony_drives_strong_notes_and_distinct_open_or_closed_arrivals() {
fn harmony_drives_strong_notes_and_the_final_ending() {
let harmony = Harmony {
length: BAR,
spans: vec![HarmonySpan {
@@ -97,13 +122,30 @@ fn harmony_drives_strong_notes_and_distinct_open_or_closed_arrivals() {
ending,
..Settings::default()
};
for c in generate_with_harmony(&demo_motif(), &s, &harmony).unwrap() {
for c in realize(
&demo_motif(),
Role::Return,
2,
6 * BAR,
true,
0,
&s,
&harmony,
)
.unwrap()
{
if c.strategy == Strategy::Quote {
continue;
}
let last = c.phrase.notes.last().unwrap();
let chord = ChordQuality::Major.mask(0) & (1 << (last.pitch % 12)) != 0;
assert_eq!(chord, ending == Ending::Resolve);
for n in c.phrase.notes.iter().filter(|n| {
n.start >= SECTION && n.start.is_multiple_of(PPQ) && n.start != last.start
}) {
assert_eq!(chord, ending == Ending::Resolve, "{:?}", c.strategy);
for n in c
.phrase
.notes
.iter()
.filter(|n| n.start.is_multiple_of(PPQ) && n.start != last.start)
{
assert_ne!(
harmony.at(n.start).unwrap().tones & (1 << (n.pitch % 12)),
0
@@ -114,29 +156,16 @@ fn harmony_drives_strong_notes_and_distinct_open_or_closed_arrivals() {
}
#[test]
fn imported_harmony_preserves_voicings_and_gaps_without_guessing_roots() {
let notes = vec![
Note {
let notes: Vec<_> = [64, 67, 72]
.into_iter()
.map(|pitch| Note {
start: 0,
duration: BAR,
pitch: 64,
pitch,
velocity: 90,
..Default::default()
},
Note {
start: 0,
duration: BAR,
pitch: 67,
velocity: 90,
..Default::default()
},
Note {
start: 0,
duration: BAR,
pitch: 72,
velocity: 90,
..Default::default()
},
];
})
.collect();
let h = Harmony::from_midi(&notes, 2 * BAR).unwrap();
assert_eq!(h.spans.len(), 1);
assert_eq!(h.spans[0].bass, 64);
@@ -145,84 +174,30 @@ fn imported_harmony_preserves_voicings_and_gaps_without_guessing_roots() {
assert_eq!(h.at(2 * BAR).unwrap().bass, 64);
}
#[test]
fn pins_combine_candidates_and_survive_regeneration_exactly() {
let mut s = Session {
source: Some(demo_motif()),
..Default::default()
};
s.regenerate().unwrap();
s.pin_selected(1).unwrap();
let saved = s.pins[0].clone();
s.selected = 1;
let expected: Vec<_> = saved
.phrase
.notes
.iter()
.map(|n| Note {
start: n.start + SECTION,
..*n
})
.collect();
let combined = s.composed_phrase().unwrap();
assert_eq!(
combined
.notes
.iter()
.filter(|n| n.start >= SECTION && n.start < 2 * SECTION)
.copied()
.collect::<Vec<_>>(),
expected
);
s.settings.seed += 7;
s.regenerate().unwrap();
assert_eq!(s.pins[0], saved);
s.accept_composed().unwrap();
assert_eq!(s.accepted, Some(s.composed_phrase().unwrap()));
assert_eq!(Session::from_json(&s.to_json().unwrap()).unwrap(), s);
}
#[test]
fn version_one_sessions_migrate_without_losing_existing_notes() {
let s = Session {
source: Some(demo_motif()),
..Default::default()
};
let mut value = serde_json::to_value(&s).unwrap();
value["version"] = 1.into();
let object = value.as_object_mut().unwrap();
for key in ["harmony", "pins", "audition", "looping"] {
object.remove(key);
fn every_meter_key_and_block_length_realizes_valid_options() {
let motif = demo_motif();
for meter in Meter::ALL {
for root in [0, 5, 11] {
for scale in Scale::ALL {
let s = Settings {
root,
scale,
meter,
low: 60,
high: 72,
..Settings::default()
};
for bars in [1, 3, 8] {
for role in Role::ALL {
for c in realize(&motif, role, bars, 0, true, 0, &s, &Harmony::default())
.unwrap()
{
c.phrase.check(MAX_PLAYBACK_NOTES, true).unwrap();
assert_eq!(c.phrase.length, bars as u32 * meter.bar());
}
}
}
}
}
}
let settings = object.get_mut("settings").unwrap().as_object_mut().unwrap();
for key in ["preserve_contour", "task", "ending"] {
settings.remove(key);
}
for n in object.get_mut("source").unwrap()["notes"]
.as_array_mut()
.unwrap()
{
n.as_object_mut().unwrap().remove("pitch_locked");
n.as_object_mut().unwrap().remove("rhythm_locked");
}
let migrated = Session::from_json(&serde_json::to_vec(&value).unwrap()).unwrap();
assert_eq!(migrated.version, STATE_VERSION);
assert_eq!(migrated.source, s.source);
assert!(!migrated.looping);
assert!(migrated.harmony.spans.is_empty());
}
#[test]
fn invalid_pins_and_unsafe_legacy_seams_are_rejected() {
let mut s = Session {
source: Some(demo_motif()),
..Default::default()
};
s.regenerate().unwrap();
s.candidates[0].phrase.notes = vec![Note {
start: SECTION - 100,
duration: 200,
pitch: 60,
velocity: 80,
..Default::default()
}];
assert!(s.pin_selected(1).is_err());
assert!(s.pin_selected(9).is_err());
}
+12 -6
View File
@@ -34,7 +34,7 @@ fn role_handoffs_preserve_event_identity_and_respect_locks() {
s.voices[1].transpose = 12;
s.voices[0].velocity = 50;
s.voices[1].velocity = 50;
let p = Performance::compile(&source, &s, 140., false).unwrap();
let p = Performance::compile(&source, &s, 140., false, Meter::default()).unwrap();
let on: Vec<_> = p
.events
.iter()
@@ -42,7 +42,7 @@ fn role_handoffs_preserve_event_identity_and_respect_locks() {
.collect();
assert_eq!(on.len(), source.notes.len());
for (i, n) in source.notes.iter().enumerate() {
let role = mode.role(i, n);
let role = mode.role(i, n, Meter::default());
let actual = on.iter().find(|e| e.tick == n.start as i32).unwrap();
assert_eq!(actual.message.channel, s.voices[role].channel);
assert_eq!(
@@ -69,7 +69,7 @@ fn controller_interpolation_and_validation_are_explicit() {
let mut s = PerformanceSettings::default();
s.voices[0].controller.enabled = true;
s.voices[0].controller.cc = 20;
let p = Performance::compile(&held(), &s, 120., false).unwrap();
let p = Performance::compile(&held(), &s, 120., false, Meter::default()).unwrap();
assert!(p
.events
.iter()
@@ -83,7 +83,7 @@ fn controller_interpolation_and_validation_are_explicit() {
fn attack_compensation_warms_up_once_and_wraps_without_cutting_the_next_note() {
let mut s = PerformanceSettings::default();
s.voices[0].attack_ms = 100;
let performance = Performance::compile(&held(), &s, 120., true).unwrap();
let performance = Performance::compile(&held(), &s, 120., true, Meter::default()).unwrap();
assert_eq!(performance.lead_in, 192);
assert!(performance
.events
@@ -127,8 +127,14 @@ fn attack_compensation_warms_up_once_and_wraps_without_cutting_the_next_note() {
}
#[test]
fn public_clip_validation_rejects_bad_roles_and_dense_events() {
let mut p =
Performance::compile(&held(), &PerformanceSettings::default(), 120., false).unwrap();
let mut p = Performance::compile(
&held(),
&PerformanceSettings::default(),
120.,
false,
Meter::default(),
)
.unwrap();
p.events[0].role = 9;
assert!(p.clip().is_err());
let event = TimedMessage {
+182
View File
@@ -0,0 +1,182 @@
use rivet_core::*;
fn demo() -> Session {
Session::demo()
}
#[test]
fn templates_build_the_story_from_one_motif() {
let s = demo();
let roles: Vec<_> = s.blocks.iter().map(|b| b.role).collect();
assert_eq!(
roles,
[Role::Statement, Role::Answer, Role::Departure, Role::Return]
);
assert_eq!(s.total_bars(), 8);
assert!(s.blocks.iter().all(|b| b.options.len() == 3));
let phrase = s.compose().unwrap();
assert_eq!(phrase.length, 8 * BAR);
assert_eq!(
&phrase.notes[..demo_motif().notes.len()],
demo_motif().notes.as_slice(),
"the story opens with the motif"
);
let mut s = demo();
let id = s.motifs[0].id;
s.apply_template(Template::Breathe, id).unwrap();
assert_eq!(s.blocks[1].role, Role::Rest);
assert_eq!(s.blocks[1].bars, 1);
assert_eq!(s.total_bars(), 8);
}
#[test]
fn blocks_have_free_lengths_up_to_the_storyboard_limit() {
let mut s = demo();
let motif = s.motifs[0].id;
s.insert_block(4, motif, Role::Departure, 5).unwrap();
s.insert_block(5, motif, Role::Rest, 1).unwrap();
assert_eq!(s.total_bars(), 14);
assert_eq!(s.compose().unwrap().length, 14 * BAR);
assert!(s.insert_block(0, motif, Role::Answer, 9).is_err());
while s.total_bars() + 8 <= MAX_BARS {
s.insert_block(0, motif, Role::Answer, 8).unwrap();
}
assert!(s.insert_block(0, motif, Role::Answer, 8).is_err());
s.validate().unwrap();
}
#[test]
fn joins_shape_the_seam_without_crossing_it() {
let mut s = demo();
let first = s.blocks[1].phrase().unwrap().notes[0];
let bar = s.settings.meter.bar();
for join in Join::ALL {
s.blocks[0].join = join;
let phrase = s.compose().unwrap();
let tail: Vec<_> = phrase
.notes
.iter()
.filter(|n| n.start < 2 * bar)
.copied()
.collect();
assert!(tail.iter().all(|n| n.end() <= 2 * bar), "{join:?}");
let last = tail.last().unwrap();
match join {
Join::Cut => assert_eq!(tail, s.blocks[0].phrase().unwrap().notes),
Join::Breath => assert!(last.end() <= 2 * bar - s.settings.meter.beat() / 2),
Join::Approach => {
assert_ne!(last.pitch, first.pitch);
assert!(last.pitch.abs_diff(first.pitch) <= 2);
}
Join::Pickup => {
let pickup: Vec<_> = tail
.iter()
.filter(|n| n.start >= 2 * bar - s.settings.meter.beat())
.collect();
assert_eq!(pickup.len(), 2);
let direction = (pickup[1].pitch as i16 - pickup[0].pitch as i16).signum();
let into = (first.pitch as i16 - pickup[1].pitch as i16).signum();
assert_eq!(direction, into, "the pickup moves toward the next block");
}
}
}
}
#[test]
fn kept_blocks_survive_new_settings_and_other_blocks_follow_them() {
let mut s = demo();
s.blocks[1].choice = 2;
s.blocks[1].kept = true;
let kept = s.blocks[1].phrase().unwrap().clone();
let free = s.blocks[2].options.clone();
s.settings.seed += 7;
s.realize_all();
assert_eq!(s.blocks[1].phrase().unwrap(), &kept);
assert_ne!(s.blocks[2].options, free);
s.another_take(1);
assert!(!s.blocks[1].kept);
assert_eq!(Session::from_json(&s.to_json().unwrap()).unwrap(), s);
}
#[test]
fn compound_and_odd_meters_compose_whole_bars() {
for meter in [
Meter { beats: 3, unit: 4 },
Meter { beats: 6, unit: 8 },
Meter { beats: 7, unit: 8 },
] {
let mut s = Session::default();
s.settings.meter = meter;
let motif = Phrase {
length: meter.bar(),
notes: (0..3)
.map(|i| Note {
start: i * meter.beat() / 2,
duration: meter.beat() / 2,
pitch: 60 + 2 * i as u8,
velocity: 90,
..Default::default()
})
.collect(),
};
let id = s.add_motif("Waltz", motif).unwrap();
s.apply_template(Template::Build, id).unwrap();
let phrase = s.compose().unwrap();
assert_eq!(phrase.length, s.total_bars() * meter.bar());
s.validate().unwrap();
}
}
#[test]
fn removing_a_motif_removes_its_blocks_and_limits_hold() {
let mut s = demo();
let id = s.motifs[0].id;
let other = s.add_motif("Second", demo_motif()).unwrap();
s.insert_block(4, other, Role::Answer, 2).unwrap();
s.remove_motif(id);
assert_eq!(s.blocks.len(), 1);
assert_eq!(s.blocks[0].motif, other);
let long = Phrase {
length: 9 * BAR,
..demo_motif()
};
assert!(s.add_motif("Too long", long).is_err());
for i in s.motifs.len()..MAX_MOTIFS {
s.add_motif(&format!("M{i}"), demo_motif()).unwrap();
}
assert!(s.add_motif("One more", demo_motif()).is_err());
}
#[test]
fn version_three_sessions_become_a_storyboard_without_losing_notes() {
let mut source = demo_motif();
source.notes[2].locked = true;
for (bars, blocks) in [(8, 4), (4, 2)] {
let old = serde_json::json!({
"version": 3,
"source": source,
"settings": {"bars": bars, "root": 2, "scale": "Dorian", "variation": 40,
"preserve_rhythm": false, "preserve_contour": true, "task": "Answer",
"ending": "Open", "low": 50, "high": 80, "seed": 9},
"candidates": [], "selected": 0, "accepted": null, "previous_accepted": null,
"tempo": 128.0, "follow_host": true, "pins": [], "looping": true,
"gestures": [{"id": 1, "name": "Hook", "phrase": demo_motif(),
"performance": PerformanceSettings::default()}],
"branches": [], "active_branch": null, "next_id": 2
});
let s = Session::from_json(&serde_json::to_vec(&old).unwrap()).unwrap();
assert_eq!(s.version, STATE_VERSION);
assert_eq!(s.motifs[0].phrase, source);
assert_eq!(s.motifs[1].name, "Hook");
assert_eq!(s.blocks.len(), blocks);
assert_eq!(s.blocks.last().unwrap().role, Role::Return);
assert_eq!(s.settings.root, 2);
assert_eq!(s.settings.scale, Scale::Dorian);
assert_eq!(s.settings.ending, Ending::Open);
assert_eq!(s.tempo, 128.);
assert!(s.follow_host);
assert!(s.compose().is_ok());
}
let v1 = serde_json::json!({"version": 1, "source": demo_motif(),
"settings": {"bars": 8}, "candidates": [], "selected": 0, "accepted": null,
"previous_accepted": null, "tempo": 140.0, "follow_host": false});
let s = Session::from_json(&serde_json::to_vec(&v1).unwrap()).unwrap();
assert!(!s.looping, "version-1 sessions kept one-shot audition");
assert!(s.harmony.spans.is_empty());
let mut future = serde_json::to_value(Session::default()).unwrap();
future["version"] = 99.into();
assert!(Session::from_json(&serde_json::to_vec(&future).unwrap()).is_err());
}