musicality 0.8.0 → 0.9.0

data/spec/performance/conversion/note_sequence_extractor_spec.rb

@@ -17,54 +17,38 @@ describe NoteSequenceExtractor do
       extr.notes.size.should eq 3
     end
 
-    it 'should remove any bad ties (tying pitch does not exist in next note' do
+    it 'should remove any links where the source pitch does not exist in the note' do
       extr = NoteSequenceExtractor.new(
-        [ Note.quarter([C4,E4], links: {C4 => Link::Tie.new}),
-          Note.quarter([E4]) ]
+        [ Note.quarter([E4], links: {C4 => Link::Tie.new}),
+          Note.quarter([C4,E4]) ]
       )
       extr.notes[0].links.should_not have_key(C4)
-    end
 
-    it 'should replace any good ties with slurs' do
       extr = NoteSequenceExtractor.new(
-        [ Note.quarter([C4,E4], links: {C4 => Link::Tie.new, E4 => Link::Tie.new}),
-          Note.quarter([C4,E4]) ]
+        [ Note.quarter([E4], links: {C4 => Link::Glissando.new(G4)}),
+          Note.quarter([C4,E4,G4]) ]
       )
-      extr.notes[0].links[C4].should be_a Link::Slur
-      extr.notes[0].links[E4].should be_a Link::Slur
-    end
+      extr.notes[0].links.should_not have_key(C4)
 
-    it 'should remove dead slur/legato (where target pitch is non-existent)' do
       extr = NoteSequenceExtractor.new(
-        [ Note.quarter([C4,E4], links: { C4 => Link::Slur.new(D4), E4 => Link::Legato.new(F4) }),
-          Note.quarter([C4]) ]
+        [ Note.quarter([E4], links: {C4 => Link::Portamento.new(G4)}),
+          Note.quarter([C4,E4,G4]) ]
       )
-      extr.notes[0].links.should be_empty
+      extr.notes[0].links.should_not have_key(C4)
     end
 
-    it 'should remove any link where the source pitch is missing' do
+    it 'should keep glissando/portamento links even when the target pitch does not exist in the next note.' do
       extr = NoteSequenceExtractor.new(
-        [ Note.quarter([C4,D4,E4,F4,G4], links: {
-            Bb4 => Link::Tie.new, Db4 => Link::Slur.new(C4),
-            Eb4 => Link::Legato.new(D4), Gb4 => Link::Glissando.new(E4),
-            Ab5 => Link::Portamento.new(F4)
-          }),
-          Note.quarter([C4,D4,E4,F4,G4])
-      ])
-      extr.notes[0].links.should be_empty
-    end
+        [ Note.quarter([C4], links: {C4 => Link::Glissando.new(G4)}),
+          Note.quarter([E4]) ]
+      )
+      extr.notes[0].links.should have_key(C4)
 
-    it 'should not remove portamento and glissando with non-existent target pitches' do
       extr = NoteSequenceExtractor.new(
-        [ Note.quarter([C4,D4]),
-          Note.quarter([C4,D4,E4,F4,G4], links: {
-            C4 => Link::Tie.new, D4 => Link::Slur.new(Eb4),
-            E4 => Link::Legato.new(Gb4), F4 => Link::Glissando.new(A5),
-            G4 => Link::Portamento.new(Bb5)}) ]
+        [ Note.quarter([C4], links: {C4 => Link::Portamento.new(G4)}),
+          Note.quarter([E4]) ]
       )
-      extr.notes[-1].links.size.should eq 2
-      extr.notes[-1].links.should have_key(F4)
-      extr.notes[-1].links.should have_key(G4)
+      extr.notes[0].links.should have_key(C4)
     end
   end
 
@@ -94,18 +78,19 @@ describe NoteSequenceExtractor do
         @seqs.size.should eq 1
       end
 
-      it 'should start offset 0' do
+      it 'should have start offset of 0' do
         @seqs[0].start.should eq 0
       end
 
-      it 'should stop offset <= note duration' do
+      it 'should have stop offset <= note duration' do
         @seqs[0].stop.should be <= @note.duration
       end
     end
 
     context 'array with two slurred notes, single pitch' do
       before :all do
-        @notes = [ Note.quarter([C5], articulation: SLUR), Note.quarter([D5]) ]
+        @notes = [ Note.quarter([C5], marks: [BEGIN_SLUR]),
+                   Note.quarter([D5], marks: [END_SLUR]) ]
         @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
       end
 
@@ -113,11 +98,11 @@ describe NoteSequenceExtractor do
         @seqs.size.should eq 1
       end
 
-      it 'should start offset 0' do
+      it 'should have start offset of 0' do
         @seqs[0].start.should eq 0
       end
 
-      it 'should stop offset <= combined duration of the two notes' do
+      it 'should have stop offset <= combined duration of the two notes' do
         @seqs[0].stop.should be <= (@notes[0].duration + @notes[1].duration)
       end
     end
@@ -140,32 +125,42 @@ describe NoteSequenceExtractor do
         @seqs.each {|s| s.stop.should be <= @note.duration }
       end
 
-      it 'should put one pitch in each seq' do
-        @seqs.each {|s| s.pitches.size.should eq(1) }
+      it 'should put one element in each seq' do
+        @seqs.each {|s| s.elements.size.should eq(1) }
       end
 
       it 'should assign a different pitch to each' do
-        @seqs.map {|seq| seq.pitches[0] }.sort.should eq @note.pitches.sort
+        @seqs.map {|seq| seq.elements.first.pitch }.sort.should eq @note.pitches.sort
       end
     end
 
     context 'array with multiple notes and links' do
       before :all do
-        @notes = [ Note.quarter([C3,E3], links: {
-          C3 => Link::Slur.new(D3), E3 => Link::Legato.new(F3)}),
-          Note.eighth([D3,F3]) ]
+        @notes = [
+          Note.quarter([C3,E3], links: { C3 => Link::Tie.new, 
+            E3 => Link::Glissando.new(G3)}),
+          Note.eighth([C3,G3])
+        ]
         @seqs = NoteSequenceExtractor.new(@notes).extract_sequences
       end
 
-      it 'should create a sequence for linked notes' do
+      it 'should create a single sequence for linked notes' do
         @seqs.size.should eq(2)
       end
 
-      it 'should add pitch at 0 from first note' do
-        @seqs[0].pitches.should have_key(0)
-        @notes[0].pitches.should include(@seqs[0].pitches[0])
-        @seqs[1].pitches.should have_key(0)
-        @notes[0].pitches.should include(@seqs[1].pitches[0])
+      it 'should set first element pitch to match first note' do
+        @seqs[0].elements.first.pitch.should eq(@notes[0].pitches[0])
+        @seqs[1].elements.first.pitch.should eq(@notes[0].pitches[1])
+      end
+
+      it 'should collapse tie link to a single element' do
+        @seqs[0].elements.size.should eq(1)
+        @seqs[0].duration.should be <= (@notes[0].duration + @notes[1].duration)
+      end
+
+      it 'should expand the glissando into multiple elements' do
+        @seqs[1].elements.size.should be > 2
+        @seqs[1].duration.should be <= (@notes[0].duration + @notes[1].duration)
       end
     end
 
@@ -180,7 +175,7 @@ describe NoteSequenceExtractor do
       end
 
       it 'should include pitches up to (not including) target pitch' do
-        @seqs[0].pitches.values.should include(D3,Eb3,E3,F3,Gb3)
+        @seqs[0].elements.map{|e| e.pitch}.should include(D3,Eb3,E3,F3,Gb3)
       end
 
       it 'should produce sequence with duration <= note duration' do
@@ -199,7 +194,7 @@ describe NoteSequenceExtractor do
       end
 
       it 'should include pitches down to (not including) target pitch' do
-        @seqs[0].pitches.values.should include(D3,Db3,C3,B2,Bb2)
+        @seqs[0].elements.map{|e| e.pitch}.should include(D3,Db3,C3,B2,Bb2)
       end
 
       it 'should produce sequence with duration <= note duration' do
@@ -219,7 +214,7 @@ describe NoteSequenceExtractor do
       end
 
       it 'should includes pitches up through target pitch' do
-        @seqs[0].pitches.values.should include(D3,Eb3,E3,F3,Gb3,G3)
+        @seqs[0].elements.map{|e| e.pitch}.should include(D3,Eb3,E3,F3,Gb3,G3)
       end
 
       it 'should produce sequence with duration <= note1dur + note2dur' do

data/spec/performance/conversion/portamento_converter_spec.rb

@@ -68,12 +68,12 @@ describe PortamentoConverter do
   describe '.portamento_elements' do
     before :all do
       @dur = Rational(3,2)
-      @acc = false
-      @els = PortamentoConverter.portamento_elements(C4,F4,25,@dur,@acc)
+      @att = Attack::NONE
+      @els = PortamentoConverter.portamento_elements(C4,F4,25,@dur,@att)
     end
     
-    it 'should return an array of SlurredElement objects' do
-      @els.each {|el| el.should be_a SlurredElement }
+    it 'should return an array of NoteSequence::Element objects' do
+      @els.each {|el| el.should be_a NoteSequence::Element }
     end
     
     it 'should split up duration among elements' do
@@ -81,11 +81,13 @@ describe PortamentoConverter do
       sum.should eq(@dur)
     end
     
-    it 'should set accented as given' do
-      els = PortamentoConverter.portamento_elements(C4,D4,10,1,false)
-      els.each {|el| el.accented.should eq(false) }
-      els = PortamentoConverter.portamento_elements(C4,D4,10,1,true)
-      els.each {|el| el.accented.should eq(true) }
+    it 'should set attack as given for first element only and set others to NONE' do
+      els = PortamentoConverter.portamento_elements(C4,D4,10,1,Attack::ACCENT)
+      els.first.attack.should eq(Attack::ACCENT)
+      els[1..-1].each {|el| el.attack.should eq(Attack::NONE) }
+      els = PortamentoConverter.portamento_elements(C4,D4,10,1,Attack::TENUTO)
+      els.first.attack.should eq(Attack::TENUTO)
+      els[1..-1].each {|el| el.attack.should eq(Attack::NONE) }
     end
   end
 end

data/spec/performance/conversion/score_collator_spec.rb

@@ -13,31 +13,31 @@ describe ScoreCollator do
     context 'first note starts before the segment start' do
       context 'first note ends right at segment start' do
         it 'should not be included in the part' do
-          score = Score::Measured.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(FOUR_FOUR, 120,
             parts: {1 => @part},
             program: ["1/4".to_r..."5/4".to_r])
           collator = ScoreCollator.new(score)
           parts = collator.collate_parts
           notes = parts[1].notes
-          notes.size.should eq(@part.notes.size - 1)
-          notes[0].pitches[0].should eq D2
-          notes[1].pitches[0].should eq E2
+          expect(notes.size).to eq(@part.notes.size - 1)
+          expect(notes[0].pitches[0]).to eq D2
+          expect(notes[1].pitches[0]).to eq E2
         end
       end
       
       context 'first note ends after segment start' do
         it 'should not be included in the part, and a rest is inserted' do
-          score = Score::Measured.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(FOUR_FOUR, 120,
             parts: {1 => @part},
             program: ["1/8".to_r..."5/4".to_r])
           collator = ScoreCollator.new(score)
           parts = collator.collate_parts
           notes = parts[1].notes
-          notes.size.should eq(@part.notes.size)
-          notes[0].pitches.should be_empty
-          notes[0].duration.should eq "1/8".to_r
-          notes[1].pitches[0].should eq D2
-          notes[2].pitches[0].should eq E2
+          expect(notes.size).to eq(@part.notes.size)
+          expect(notes[0].pitches).to be_empty
+          expect(notes[0].duration).to eq "1/8".to_r
+          expect(notes[1].pitches[0]).to eq D2
+          expect(notes[2].pitches[0]).to eq E2
         end
       end
     end
@@ -45,47 +45,47 @@ describe ScoreCollator do
     context 'first note starts at segment start' do
       context 'last note starts at program end' do
         it 'should not be included in the part' do
-          score = Score::Measured.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(FOUR_FOUR, 120,
             parts: {1 => @part},
             program: [0.to_r..."3/4".to_r])
           collator = ScoreCollator.new(score)
           parts = collator.collate_parts
           notes = parts[1].notes
-          notes.size.should eq(@part.notes.size - 1)
+          expect(notes.size).to eq(@part.notes.size - 1)
         end
       end
       
       context 'last note start before program end, but lasts until after' do
         it 'should be included in the part, but truncated' do
-          score = Score::Measured.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(FOUR_FOUR, 120,
             parts: {1 => @part},
             program: [0.to_r...1.to_r])
           collator = ScoreCollator.new(score)
           parts = collator.collate_parts
           notes = parts[1].notes
-          notes.size.should eq(@part.notes.size)
-          notes[-1].duration.should eq("1/4".to_r)
+          expect(notes.size).to eq(@part.notes.size)
+          expect(notes[-1].duration).to eq("1/4".to_r)
         end
       end
       
       context 'last note ends before program segment end' do
         it 'should insert a rest between last note end and segment end' do
-          score = Score::Measured.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(FOUR_FOUR, 120,
             parts: {1 => @part},
             program: [0.to_r..."6/4".to_r])
           collator = ScoreCollator.new(score)
           parts = collator.collate_parts
           notes = parts[1].notes
-          notes.size.should eq(@part.notes.size + 1)
-          notes[-1].pitches.should be_empty
-          notes[-1].duration.should eq("1/4".to_r)
+          expect(notes.size).to eq(@part.notes.size + 1)
+          expect(notes[-1].pitches).to be_empty
+          expect(notes[-1].duration).to eq("1/4".to_r)
         end
       end
     end
     
     context 'part contains trimmed gradual changes' do
       it 'should exclude the change when it is not at all in a program segment' do
-        score = Score::Measured.new(FOUR_FOUR, 120,
+        score = Score::Tempo.new(FOUR_FOUR, 120,
           parts: { 1 => Part.new(Dynamics::FF, dynamic_changes: {
             2 => Change::Gradual.linear(Dynamics::PP,5).trim(1,0)
           }) },
@@ -94,19 +94,19 @@ describe ScoreCollator do
         collator = ScoreCollator.new(score)
         parts = collator.collate_parts
         dcs = parts[1].dynamic_changes
-        dcs.size.should eq(1)
-        dcs[0.to_r].should eq(Change::Immediate.new(Dynamics::PP))
+        expect(dcs.size).to eq(0)
+        expect(parts[1].start_dynamic).to be_within(1e-5).of(Dynamics::PP)
         
         score.program = [0...1]
         collator = ScoreCollator.new(score)
         parts = collator.collate_parts
         dcs = parts[1].dynamic_changes
-        dcs.size.should eq(1)
-        dcs[0.to_r].should eq(Change::Immediate.new(Dynamics::FF))
+        expect(dcs.size).to eq(0)
+        expect(parts[1].start_dynamic).to be_within(1e-5).of(Dynamics::FF)
       end
       
       it 'should trim the change further if needed' do
-        score = Score::Measured.new(FOUR_FOUR, 120,
+        score = Score::Tempo.new(FOUR_FOUR, 120,
           parts: { 1 => Part.new(Dynamics::FF, dynamic_changes: {
             2 => Change::Gradual.linear(Dynamics::PP,5).trim(1,1)
           }) },
@@ -115,14 +115,14 @@ describe ScoreCollator do
         collator = ScoreCollator.new(score)
         parts = collator.collate_parts
         dcs = parts[1].dynamic_changes
-        dcs.size.should eq(1)
-        dcs[0.to_r].should eq(Change::Gradual.linear(Dynamics::PP,5).trim(2,2))
+        expect(dcs.size).to eq(1)
+        expect(dcs[0.to_r]).to eq(Change::Gradual.linear(Dynamics::PP,5).trim(2,2))
       end
     end
     
     it 'should preserve links' do
-      notes = Note.split_parse("1Db4~Bb4")
-      score = Score::Measured.new(
+      notes = Note.split_parse("1Db4;Bb4")
+      score = Score::Tempo.new(
         FOUR_FOUR,120,
         parts: { "lead" => Part.new(Dynamics::MP, notes: notes) },
         program: [0..1,0..1],
@@ -131,10 +131,10 @@ describe ScoreCollator do
       parts = collator.collate_parts
       
       notes = parts["lead"].notes
-      notes.size.should eq 2
+      expect(notes.size).to eq 2
       notes.each do |note|
-        note.links.should have_key(Db4)
-        note.links[Db4].should be_a Link::Glissando
+        expect(note.links).to have_key(Db4)
+        expect(note.links[Db4]).to be_a Link::Glissando
       end
     end
   end
@@ -148,59 +148,56 @@ describe ScoreCollator do
     
     context 'tempo change starts at end of program segment' do
       it 'should not be included in the tempo changes' do
-        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
-          1 => @change1, 2 => @change2 }, program: [0..2])
+        score = Score::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
+          1 => @change1, 2 => @change2 }, program: [0...2])
         collator = ScoreCollator.new(score)
-        tcs = collator.collate_tempo_changes
-        tcs.size.should eq 2
-        tcs[0.to_r].should eq @change0
-        tcs[1.to_r].should eq @change1
+        st, tcs = collator.collate_tempo_changes
+        expect(tcs.size).to eq 1
+        expect(tcs[1.to_r]).to eq @change1
       end
     end
 
     context 'tempo change starts and ends before segment' do
       before :all do
-        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
+        score = Score::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
           2 => @change2 }, program: [4..5])
         collator = ScoreCollator.new(score)
-        @tcs = collator.collate_tempo_changes
+        @st, @tcs = collator.collate_tempo_changes
       end
       
       it 'should not be included in the tempo changes' do
-        @tcs.size.should eq 1
-        @tcs[0.to_r].should be_a Change::Immediate
+        expect(@tcs.size).to eq 0
       end
       
-      it 'should be used as starting tempo change end_value' do
-        @tcs[0.to_r].end_value.should eq @change2.end_value
+      it 'should be used as start tempo' do
+        expect(@st).to be_within(1e-5).of @change2.end_value
       end
     end
     
     context 'tempo change starts before segment, but ends during segment' do
       it 'should e included in the tempo changes, but truncated' do
-        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
+        score = Score::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
           1.5.to_r => @change2 }, program: [2..4])
         collator = ScoreCollator.new(score)
-        tcs = collator.collate_tempo_changes
-        tcs.size.should eq 1
-        tcs[0.to_r].should be_a Change::Gradual::Trimmed
-        tcs[0.to_r].end_value.should eq @change2.end_value
-        tcs[0.to_r].remaining.should eq(0.5)
+        st, tcs = collator.collate_tempo_changes
+        expect(tcs.size).to eq 1
+        expect(tcs[0.to_r]).to be_a Change::Gradual::Trimmed
+        expect(tcs[0.to_r].end_value).to eq @change2.end_value
+        expect(tcs[0.to_r].remaining).to eq(0.5)
       end
     end
     
     context 'tempo change starts during segment, lasts until after' do
       it 'should be included in the tempo changes, but truncated' do
-        score = Score::Measured.new(FOUR_FOUR, 120, tempo_changes: {
+        score = Score::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
           1 => @change1, 2 => @change2 }, program: [0..2.5])
         collator = ScoreCollator.new(score)
-        tcs = collator.collate_tempo_changes
-        tcs.size.should eq 3
-        tcs[0.to_r].should eq @change0
-        tcs[1.to_r].should eq @change1
-        tcs[2.to_r].should be_a Change::Gradual::Trimmed
-        tcs[2.to_r].end_value.should eq @change2.end_value
-        tcs[2.to_r].remaining.should eq(0.5)
+        st, tcs = collator.collate_tempo_changes
+        expect(tcs.size).to eq 2
+        expect(tcs[1.to_r]).to eq @change1
+        expect(tcs[2.to_r]).to be_a Change::Gradual::Trimmed
+        expect(tcs[2.to_r].end_value).to eq @change2.end_value
+        expect(tcs[2.to_r].remaining).to eq(0.5)
       end
     end
   end
@@ -210,13 +207,12 @@ describe ScoreCollator do
       change0 = Change::Immediate.new(FOUR_FOUR)
       change1 = Change::Immediate.new(THREE_FOUR)
       change2 = Change::Immediate.new(SIX_EIGHT)
-      score = Score::Measured.new(FOUR_FOUR, 120, meter_changes: {
+      score = Score::Tempo.new(FOUR_FOUR, 120, meter_changes: {
         1 => change1, 2 => change2 }, program: [0...2])
       collator = ScoreCollator.new(score)
-      tcs = collator.collate_meter_changes
-      tcs.size.should eq 2
-      tcs[0.to_r].should eq change0
-      tcs[1.to_r].should eq change1
+      sm, mcs = collator.collate_meter_changes
+      expect(mcs.size).to eq 1
+      expect(mcs[1.to_r]).to eq change1
     end
   end
 end