music-performance 0.2.1

data/spec/conversion/portamento_converter_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe PortamentoConverter do
+  describe '.portamento_pitches' do
+    context 'start pitch <= target_pitch' do
+      [
+        [C4,E4,10],
+        [D2,G3,11],
+        [C4.transpose(0.5), A4.transpose(-0.3), 12],
+        [D5,D5,7],
+        [D5,D5.transpose(0.06),7],
+        [D5,D5.transpose(0.07),7],
+        [D5,D5.transpose(0.08),7],
+      ].each do |start,finish,step_size|
+        context "start at #{start.to_s}, end at #{finish.to_s}" do
+          pitches = PortamentoConverter.portamento_pitches(start,finish,step_size)
+          
+          it 'should begin at start pitch' do
+            pitches.first.should eq(start)
+          end
+          
+          it 'should space pitches using given cent step size' do
+            (1...pitches.size).each do |i|
+              diff = pitches[i].total_cents - pitches[i-1].total_cents
+              diff.should eq(step_size)
+            end
+          end
+          
+          it 'should end where one more step would be >= target pitch' do
+            diff = finish.total_cents - pitches.last.total_cents
+            diff.should be <= step_size
+          end
+        end
+      end
+    end
+
+    context 'start pitch > target_pitch' do
+      [
+        [E4,C4,10],
+        [G3,D2,11],
+        [A4,Bb3,12],
+        [A4.transpose(-0.33),Bb3.transpose(0.11),13],
+        [Bb3.transpose(0.64),Bb3.transpose(0.54),14],
+      ].each do |start,finish,step_size|
+        context "start at #{start.to_s}, end at #{finish.to_s}" do
+          pitches = PortamentoConverter.portamento_pitches(start,finish,step_size)
+          
+          it 'should begin at start pitch' do
+            pitches.first.should eq(start)
+          end
+          
+          it 'should space pitches using negative of given cent step size' do
+            (1...pitches.size).each do |i|
+              diff = pitches[i-1].total_cents - pitches[i].total_cents
+              diff.should eq(step_size)
+            end
+          end
+          
+          it 'should end where one more step would be <= target pitch' do
+            diff = pitches.last.total_cents - finish.total_cents
+            diff.should be <= step_size
+          end
+        end
+      end
+    end
+  end
+  
+  describe '.portamento_elements' do
+    before :all do
+      @dur = Rational(3,2)
+      @acc = false
+      @els = PortamentoConverter.portamento_elements(C4,F4,25,@dur,@acc)
+    end
+    
+    it 'should return an array of SlurredElement objects' do
+      @els.each {|el| el.should be_a SlurredElement }
+    end
+    
+    it 'should split up duration among elements' do
+      sum = @els.map {|el| el.duration }.inject(0,:+)
+      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) }
+    end
+  end
+end

data/spec/conversion/score_collator_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe ScoreCollator do
+  describe '#collate_parts' do
+    before :all do
+      @part = Part.new(Dynamics::FF,
+        notes: [ Note.quarter([C2]),
+          Note.half([D2]),
+          Note.half([E2])
+      ])
+    end
+    
+    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.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new(["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
+        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.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new(["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
+        end
+      end
+    end
+    
+    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.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new([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)
+        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.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new([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)
+        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.new(FOUR_FOUR, 120,
+            parts: {1 => @part},
+            program: Program.new([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)
+        end
+      end
+    end
+  end
+  
+  describe '#collate_tempo_changes' do
+    before :all do
+      @change0 = Change::Immediate.new(120)
+      @change1 = Change::Immediate.new(200)
+      @change2 = Change::Gradual.new(100,1)
+    end
+    
+    context 'tempo change at end of program segment' do
+      it 'should not be included in the tempo changes' do
+        score = Score.new(FOUR_FOUR, 120, tempo_changes: {
+          1 => @change1, 2 => @change2 }, program: Program.new([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
+      end
+    end
+    
+    context 'tempo change starts before segment end, lasts until after' do
+      it 'should be included in the tempo changes, but truncated' do
+        score = Score.new(FOUR_FOUR, 120, tempo_changes: {
+          1 => @change1, 2 => @change2 }, program: Program.new([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 eq @change2
+        tcs[2.to_r].duration.should eq(0.5)
+        tcs[2.to_r].value.should eq(150.0)
+      end
+    end
+  end
+
+  describe '#collate_meter_changes' do
+    it 'should behave just as #collate_tempo_changes' do
+      change0 = Change::Immediate.new(FOUR_FOUR)
+      change1 = Change::Immediate.new(THREE_FOUR)
+      change2 = Change::Immediate.new(SIX_EIGHT)
+      score = Score.new(FOUR_FOUR, 120, meter_changes: {
+        1 => change1, 2 => change2 }, program: Program.new([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
+    end
+  end
+end

data/spec/conversion/score_time_converter_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ScoreTimeConverter do
+  before :all do
+    @score = Score.new(
+      Meter.new(4,"1/4".to_r),
+      120,
+      program: Program.new([(1.to_r)...(2.to_r)]),
+      parts: {
+        "abc" => Part.new(
+          Dynamics::MF,
+          notes: [
+            Note.new(0.1,[C5]),
+            Note.new(0.2,[D5]),
+            Note.new(0.3,[C5]),
+            Note.new(0.4,[D5]),
+          ]
+        )
+      },
+    )
+    @converter = ScoreTimeConverter.new(@score,1000)
+  end
+
+  describe '#convert_parts' do
+    before :all do
+      @timeparts = @converter.convert_parts
+    end
+    
+    it 'should return a hash of Part objects' do
+      @timeparts.values.count {|v| !v.is_a?(Part)}.should eq 0
+    end
+    
+    it "should produce notes with duration appropriate to the tempo" do
+      part = @timeparts.values.first
+      part.notes[0].duration.should be_within(0.01).of(0.2)
+      part.notes[1].duration.should be_within(0.01).of(0.4)
+      part.notes[2].duration.should be_within(0.01).of(0.6)
+      part.notes[3].duration.should be_within(0.01).of(0.8)
+    end
+    
+    it "should produce notes twice as long when tempo is half" do
+      score = @score.clone
+      score.parts.values.first.notes.concat [
+        Note.new(0.2,[C5]), Note.new(0.4,[D5]), Note.new(0.3,[C5]), Note.new(0.1,[D5]) ]
+      score.tempo_changes[1.to_r] = Change::Immediate.new(60)
+      converter = ScoreTimeConverter.new(score,1000)
+      timeparts = converter.convert_parts
+      
+      part = timeparts.values.first
+      part.notes[0].duration.should be_within(0.01).of(0.2)
+      part.notes[1].duration.should be_within(0.01).of(0.4)
+      part.notes[2].duration.should be_within(0.01).of(0.6)
+      part.notes[3].duration.should be_within(0.01).of(0.8)
+      
+      part.notes[4].duration.should be_within(0.01).of(0.8)
+      part.notes[5].duration.should be_within(0.01).of(1.6)
+      part.notes[6].duration.should be_within(0.01).of(1.2)
+      part.notes[7].duration.should be_within(0.01).of(0.4)      
+    end
+  end
+
+  describe '#convert_program' do
+    before :all do
+      @timeprogram = @converter.convert_program
+    end
+    
+    it 'should convert note offsets to time offsets' do
+      timeseg = @timeprogram.segments[0]
+      timeseg.first.should be_within(0.01).of(2)
+      timeseg.last.should be_within(0.01).of(4)
+    end
+  end
+end

data/spec/model/note_sequence_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe NoteSequence do
+  describe '#initialize' do
+    it 'should assign given start, stop, pitches and attacks' do
+      start, stop = 15, 22
+      pitches = { 15 => F2, 16 => G2, 16.1 => Ab2, 21.99 => C2 }
+      attacks = { 15 => ACCENTED, 17 => UNACCENTED, 18 => ACCENTED }
+      seq = NoteSequence.new(start,stop,pitches,attacks)
+      seq.start.should eq(start)
+      seq.stop.should eq(stop)
+      seq.pitches.should eq(pitches)
+      seq.attacks.should eq(attacks)
+    end
+    
+    it 'should raise ArgumentError if start offset >= stop offset' do
+      expect do
+        NoteSequence.new(20,19, { 20 => C4 }, { 20 => UNACCENTED })
+      end.to raise_error(ArgumentError)
+    end
+    
+    it 'should raise ArgumentError if no pitches are given' do
+      expect do
+        NoteSequence.new(20,21, {}, { 20 => UNACCENTED })
+      end.to raise_error(ArgumentError)
+    end
+    
+    it 'should raise ArgumentError if no attacks are given' do
+      expect do
+        NoteSequence.new(20,21, { 20 => C4 }, {})
+      end.to raise_error(ArgumentError)
+    end
+    
+    it 'should raise ArgumentError if no start pitch is given' do
+      expect do
+        NoteSequence.new(20,21, { 20.1 => C4 }, { 20 => UNACCENTED })
+      end.to raise_error(ArgumentError)
+    end
+    
+    it 'should raise ArgumentError if no start attack is given' do
+      expect do
+        NoteSequence.new(20,21, { 20 => C4 }, { 20.1 => UNACCENTED })
+      end.to raise_error(ArgumentError)
+    end
+    
+    it 'should raise ArgumentError if any pitch offset is not between start..stop' do
+      expect do
+        NoteSequence.new(20,21, { 20 => C4, 21.01 => D4 }, { 20 => UNACCENTED })
+      end.to raise_error(ArgumentError)
+      
+      expect do
+        NoteSequence.new(20,21, { 20 => C4, 19.99 => D4 }, { 20 => UNACCENTED })
+      end.to raise_error(ArgumentError)
+    end
+    
+    it 'should raise ArgumentError if any attack offset is not between start..stop' do
+      expect do
+        NoteSequence.new(20,21, { 20 => C4 }, { 20 => UNACCENTED, 21.01 => ACCENTED })
+      end.to raise_error(ArgumentError)
+      
+      expect do
+        NoteSequence.new(20,21, { 20 => C4 }, { 20 => UNACCENTED, 19.99 => ACCENTED })
+      end.to raise_error(ArgumentError)
+    end
+  end
+  
+  describe '.from_elements' do
+    it 'should raise ArgumentError if no elements are given' do
+      expect { NoteSequence.from_elements(2,[]) }.to raise_error(ArgumentError)
+    end
+    
+    context 'single element' do
+      before :all do
+        @offset = 0
+        @el = FinalElement.new(2, C2, true, NORMAL)
+        @seq = NoteSequence.from_elements(@offset, [ @el ])
+        
+      end
+      
+      it 'should return a NoteSequence' do
+        @seq.should be_a NoteSequence
+      end
+      
+      it 'should set start offset to given offset' do
+        @seq.start.should eq(@offset)
+      end
+      
+      it 'should set stop offset no more than "duration of first element" away from start' do
+        (@seq.stop - @seq.start).should be <= @el.duration
+      end
+      
+      it 'should set start pitch according to element pitch' do
+        @seq.pitches[@seq.start].should eq(@el.pitch)
+      end
+      
+      it 'should set start attack according to element.accented' do
+        @seq.attacks[@seq.start].accented?.should eq(@el.accented)
+      end
+    end
+    
+    context 'multi-element' do
+      before :all do
+        @offset = 1.5
+        @els = [
+          SlurredElement.new(1.0, A2, false),
+          LegatoElement.new(1.1, B2, false),
+          SlurredElement.new(1.2, C2, false),
+          LegatoElement.new(1.3, B2, false),
+          FinalElement.new(1.4, A2, false, NORMAL)
+        ]
+        @seq = NoteSequence.from_elements(@offset, @els)
+      end
+      
+      it 'should place pitches according to element duration' do
+        offset = @offset
+        @els.each do |el|
+          @seq.pitches.should have_key(offset)
+          @seq.pitches[offset].should eq(el.pitch)
+          offset += el.duration
+        end
+      end
+      
+      it 'should place attacks at beginning and following non-slur elements' do
+        @seq.attacks.should have_key(@offset)
+        
+        offset = @offset + @els.first.duration
+        (1...@els.size).each do |i|
+          unless @els[i-1].slurred?
+            @seq.attacks.should have_key(offset)
+          end
+          offset += @els[i].duration
+        end
+      end
+    end
+    
+    context 'elements contain slur to same pitch' do
+      it 'should not add same pitch nor attack for second element' do
+        els = [ SlurredElement.new(1, C4, false), FinalElement.new(1, C4, false, NORMAL) ]
+        seq = NoteSequence.from_elements(0, els)
+        seq.pitches.should have_key(0)
+        seq.pitches.should_not have_key(1)
+        seq.attacks.should have_key(0)
+        seq.attacks.should_not have_key(1)
+      end
+    end
+  end
+end