musicality 0.2.0 → 0.3.0

data/spec/notation/conversion/measured_score_converter_spec.rb

@@ -1,329 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe MeasuredScoreConverter do
-  describe '#initialize' do
-    context 'current score is invalid' do
-      it 'should raise NotValidError' do
-        score = Score::Measured.new(1, 120)
-        expect { MeasuredScoreConverter.new(score) }.to raise_error(NotValidError)
-      end
-    end    
-  end
-  
-  describe '#convert_parts' do
-    before :each do
-      @changeA = Change::Immediate.new(Dynamics::PP)
-      @changeB = Change::Gradual.new(Dynamics::F, 2)
-      @score = Score::Measured.new(FOUR_FOUR, 120,
-        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => @changeA, 3 => @changeB })}
-      )
-    end
-    
-    it 'should return Hash with original part names' do
-      parts = MeasuredScoreConverter.new(@score).convert_parts
-      parts.should be_a Hash
-      parts.keys.sort.should eq(@score.parts.keys.sort)
-    end
-    
-    it 'should convert part dynamic change offsets from measure-based to note-based' do
-      parts = MeasuredScoreConverter.new(@score).convert_parts
-      parts.should have_key("simple")
-      part = parts["simple"]
-      part.dynamic_changes.keys.sort.should eq([1,3])
-      change = part.dynamic_changes[Rational(1,1)]
-      change.value.should eq(@changeA.value)
-      change.duration.should eq(0)
-      change = part.dynamic_changes[Rational(3,1)]
-      change.value.should eq(@changeB.value)
-      change.duration.should eq(2)
-      
-      @score.start_meter = THREE_FOUR
-      parts = MeasuredScoreConverter.new(@score).convert_parts
-      parts.should have_key("simple")
-      part = parts["simple"]
-      part.dynamic_changes.keys.sort.should eq([Rational(3,4),Rational(9,4)])
-      change = part.dynamic_changes[Rational(3,4)]
-      change.value.should eq(@changeA.value)
-      change.duration.should eq(0)
-      change = part.dynamic_changes[Rational(9,4)]
-      change.value.should eq(@changeB.value)
-      change.duration.should eq(1.5)
-    end
-    
-    context 'gradual changes with positive elapsed and/or remaining' do
-      it 'should change elapsed and remaining so they reflect note-based offsets' do
-        score = Score::Measured.new(THREE_FOUR,120, parts: {
-          "abc" => Part.new(Dynamics::P, dynamic_changes: {
-              2 => Change::Gradual.new(Dynamics::F,2,1,3),
-              7 => Change::Gradual.new(Dynamics::F,1,4,5)
-          })
-        })
-        converter = MeasuredScoreConverter.new(score)
-        parts = converter.convert_parts
-        dcs = parts["abc"].dynamic_changes
-        
-        dcs.keys.should eq([Rational(6,4), Rational(21,4)])
-        dcs[Rational(3,2)].should eq(Change::Gradual.new(Dynamics::F,Rational(6,4),Rational(3,4),Rational(9,4)))
-        dcs[Rational(21,4)].should eq(Change::Gradual.new(Dynamics::F,Rational(3,4),Rational(12,4),Rational(15,4)))
-      end
-    end
-  end
-  
-  describe '#convert_program' do
-    before :each do
-      @prog = Program.new([0...4,2...5])
-      @score = Score::Measured.new(FOUR_FOUR, 120, program: @prog)
-      @converter = MeasuredScoreConverter.new(@score)
-    end
-    
-    it 'shuld return Program with same number of segments' do
-      prog = @converter.convert_program
-      prog.should be_a Program
-      prog.segments.size.should eq(@score.program.segments.size)
-    end
-  
-    it 'should convert program segments offsets from measure-based to note-based' do
-      prog = MeasuredScoreConverter.new(@score).convert_program
-      prog.segments.size.should eq(2)
-      prog.segments[0].first.should eq(0)
-      prog.segments[0].last.should eq(4)
-      prog.segments[1].first.should eq(2)
-      prog.segments[1].last.should eq(5)
-      
-      @score.start_meter = THREE_FOUR
-      prog = MeasuredScoreConverter.new(@score).convert_program
-      prog.segments.size.should eq(2)
-      prog.segments[0].first.should eq(0)
-      prog.segments[0].last.should eq(3)
-      prog.segments[1].first.should eq(1.5)
-      prog.segments[1].last.should eq(3.75)
-    end
-  end
-  
-  describe '#convert_start_tempo' do
-    it 'should return a converted tempo object, with same type as givn tempo class' do
-      score = Score::Measured.new(SIX_EIGHT, 120)
-      converter = MeasuredScoreConverter.new(score)
-      tempo = converter.convert_start_tempo
-      tempo.should eq(180)
-    end
-  end
-  
-  describe '#convert_tempo_changes' do
-    context 'immediate tempo changes' do
-      before :all do
-        @score = Score::Measured.new(THREE_FOUR, 120,
-          tempo_changes: { 1 => Change::Immediate.new(100),
-            2.5 => Change::Immediate.new(90)}
-        )
-        @tcs = MeasuredScoreConverter.new(@score).convert_tempo_changes
-      end
-      
-      it 'should change offset from measure-based to note-based' do
-        @tcs.keys.sort.should eq([0.75, 1.875])
-      end
-      
-      it 'should change tempo value using Tempo::BPM.to_qnpm' do
-        @tcs.entries.first[1].value.should eq(Tempo::BPM.to_qnpm(100,Rational(1,4)))
-        @tcs.entries.last[1].value.should eq(Tempo::BPM.to_qnpm(90,Rational(1,4)))
-      end
-    end
-    
-    context 'gradual tempo changes' do
-      context 'no meter changes within tempo change duration' do
-        before :all do
-          @score = Score::Measured.new(THREE_FOUR, 120,
-            tempo_changes: { 2 => Change::Gradual.new(100,2) },
-            meter_changes: { 1 => Change::Immediate.new(TWO_FOUR),
-                             4 => Change::Immediate.new(SIX_EIGHT) }
-          )
-          @tcs = MeasuredScoreConverter.new(@score).convert_tempo_changes
-        end
-  
-        it 'should change tempo change offset to note-based' do
-          @tcs.keys.should eq([Rational(5,4)])
-        end
-        
-        it 'should convert the tempo change' do
-          @tcs[Rational(5,4)].value.should eq(Tempo::BPM.to_qnpm(100,Rational(1,4)))
-        end
-        
-        it 'should convert change duration to note-based' do
-          @tcs[Rational(5,4)].duration.should eq(1)
-        end
-      end
-      
-      context 'single meter change within tempo change duration' do
-        before :all do
-          @tc_moff, @mc_moff = 2, 4
-          @tc = Change::Gradual.new(100,4)
-          @score = Score::Measured.new(THREE_FOUR, 120,
-            tempo_changes: { @tc_moff => @tc },
-            meter_changes: { @mc_moff => Change::Immediate.new(SIX_EIGHT) }
-          )
-          @tcs = MeasuredScoreConverter.new(@score).convert_tempo_changes
-          @mnoff_map = @score.measure_note_map
-          
-          mend = @tc_moff + @tc.impending + @tc.remaining
-          @ndur = @mnoff_map[mend] - @mnoff_map[mend - @tc.total_duration]
-        end
-  
-        it 'should split the one gradual change into two, durations adding to original total' do
-          @tcs.size.should eq(2)
-          @tcs.values.each {|x| x.should be_a Change::Gradual }
-        end
-        
-        it 'should make each with same total duration' do
-          @tcs.values.each {|x| x.total_duration.should eq(@ndur) }
-        end
-        
-        it 'should make durations so they sum to make the total duration' do
-          @tcs.values.map {|x| x.duration }.inject(0,:+).should eq(@ndur)
-        end
-        
-        it 'should start first split change where original change would start' do
-          @tcs.should have_key(@mnoff_map[@tc_moff])
-        end
-        
-        it 'should stop first split, and start second split where inner meter change occurs' do
-          pc1_start_noff = @mnoff_map[@tc_moff]
-          pc1_end_noff  = pc1_start_noff + @tcs[pc1_start_noff].duration
-          
-          pc2_start_noff = @mnoff_map[@mc_moff]
-          @tcs.should have_key(pc2_start_noff)
-          pc1_end_noff.should eq(pc2_start_noff)
-        end
-        
-        it 'should stop second split change where original change would end' do
-          pc2_start_noff = @mnoff_map[@mc_moff]
-          pc2_end_noff = pc2_start_noff + @tcs[pc2_start_noff].duration
-          pc2_end_noff.should eq(@mnoff_map[@tc_moff + @tc.duration])
-        end
-      end
-  
-      context 'two meter changes within tempo change duration' do
-        before :all do
-          @tc_moff, @mc1_moff, @mc2_moff = 2, 4, 5
-          @tc = Change::Gradual.new(100,5)
-          @score = Score::Measured.new(THREE_FOUR, 120,
-            tempo_changes: { @tc_moff =>  @tc},
-            meter_changes: { @mc1_moff => Change::Immediate.new(SIX_EIGHT),
-                             @mc2_moff => Change::Immediate.new(TWO_FOUR) }
-          )
-          @tcs = MeasuredScoreConverter.new(@score).convert_tempo_changes
-          @mnoff_map = @score.measure_note_map
-          
-          mend = @tc_moff + @tc.impending + @tc.remaining
-          @ndur = @mnoff_map[mend] - @mnoff_map[mend - @tc.total_duration]
-        end
-  
-        it 'should split the one gradual change into three' do
-          @tcs.size.should eq(3)
-          @tcs.values.each {|x| x.should be_a Change::Gradual }
-        end
-        
-        it 'should make each with same total duration' do
-          @tcs.values.each {|x| x.total_duration.should eq(@ndur) }
-        end
-        
-        it 'should make durations so they sum to make the total duration' do
-          @tcs.values.map {|x| x.duration }.inject(0,:+).should eq(@ndur)
-        end
-        
-        it 'should start first split change where original change would start' do
-          @tcs.should have_key(@mnoff_map[@tc_moff])
-        end
-        
-        it 'should stop first split, and start second split change where 1st meter change occurs' do
-          pc1_start_noff = @mnoff_map[@tc_moff]
-          pc1_end_noff  = pc1_start_noff + @tcs[pc1_start_noff].duration
-          
-          pc2_start_noff = @mnoff_map[@mc1_moff]
-          @tcs.should have_key(pc2_start_noff)
-          pc1_end_noff.should eq(pc2_start_noff)
-        end
-        
-        it 'should stop second split, and start third split change where 2st meter change occurs' do
-          pc2_start_noff = @mnoff_map[@mc1_moff]
-          pc2_end_noff  = pc2_start_noff + @tcs[pc2_start_noff].duration
-          
-          pc3_start_noff = @mnoff_map[@mc2_moff]
-          @tcs.should have_key(pc3_start_noff)
-          pc2_end_noff.should eq(pc3_start_noff)
-        end
-        
-        it 'should stop third split change where original change would end' do
-          pc3_start_noff = @mnoff_map[@mc2_moff]
-          pc3_end_noff = pc3_start_noff + @tcs[pc3_start_noff].duration
-          pc3_end_noff.should eq(@mnoff_map[@tc_moff + @tc.duration])
-        end
-      end
-    end
-    
-    context 'gradual tempo changes with positive elapsed and/or remaining' do
-      context 'no meter change during tempo change' do
-        it 'should simply change elapsed and remaining so they reflect note-based offsets' do
-          score = Score::Measured.new(THREE_FOUR,120, tempo_changes: {
-            3 => Change::Gradual.new(100,5,2,3)
-          })
-          converter = MeasuredScoreConverter.new(score)
-          tcs = converter.convert_tempo_changes
-          
-          tcs.keys.should eq([Rational(9,4)])
-          tcs[Rational(9,4)].should eq(Change::Gradual.new(100,Rational(15,4),Rational(6,4),Rational(9,4)))
-        end
-      end
-      
-      context 'meter changes during tempo change' do
-        it 'should split tempo change, converting and adjusting elapsed/remaining with each sub-change' do
-          score = Score::Measured.new(THREE_FOUR,120,
-            meter_changes: { 4 => Change::Immediate.new(SIX_EIGHT),
-                             6 => Change::Immediate.new(TWO_FOUR) },
-            tempo_changes: { 3 => Change::Gradual.new(100,5,2,3) }
-          )
-          converter = MeasuredScoreConverter.new(score)
-          tcs = converter.convert_tempo_changes
-          
-          tcs.keys.should eq([Rational(9,4), Rational(12,4), Rational(18,4)])
-          tcs[Rational(9,4)].should eq(Change::Gradual.new(100,0.75,1.5,4))
-          tcs[Rational(12,4)].should eq(Change::Gradual.new(Tempo::BPM.to_qnpm(100,SIX_EIGHT.beat_duration),1.5,2.25,2.5))
-          tcs[Rational(18,4)].should eq(Change::Gradual.new(Tempo::BPM.to_qnpm(100,TWO_FOUR.beat_duration),1,3.75,1.5))
-        end
-      end
-    end
-  end
-  
-  describe '#convert_score' do    
-    it 'should return an unmeasured score' do
-      score = Score::Measured.new(FOUR_FOUR, 120)
-      converter = MeasuredScoreConverter.new(score)
-      converter.convert_score.should be_a Score::Unmeasured
-    end
-  
-    it 'should use output from convert_start_tempo' do
-      score = Score::Measured.new(FOUR_FOUR, 120)
-      converter = MeasuredScoreConverter.new(score)
-      nscore = converter.convert_score
-      nscore.start_tempo.should eq(converter.convert_start_tempo)
-    end
-    
-    it 'should use output from convert_program' do
-      prog = Program.new([0...4,2...5])
-      score = Score::Measured.new(FOUR_FOUR, 120, program: prog)
-      converter = MeasuredScoreConverter.new(score)
-      nscore = converter.convert_score
-      nscore.program.should eq(converter.convert_program)
-    end
-    
-    it 'should use output from convert_parts' do
-      changeA = Change::Immediate.new(Dynamics::PP)
-      changeB = Change::Gradual.new(Dynamics::F, 2)
-      score = Score::Measured.new(FOUR_FOUR, 120,
-        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
-      )
-      converter = MeasuredScoreConverter.new(score)
-      nscore = converter.convert_score
-      nscore.parts.should eq(converter.convert_parts)
-    end
-  end
-end

data/spec/notation/conversion/unmeasured_score_conversion_spec.rb

@@ -1,71 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Score::Unmeasured do
-  before :all do
-    @parts = {
-      "piano" => Part.new(Dynamics::MP,
-        notes: [Note.quarter(C4), Note.eighth(F3), Note.whole(C4), Note.half(D4)]*12,
-        dynamic_changes: {
-          1 => Change::Immediate.new(Dynamics::MF),
-          5 => Change::Immediate.new(Dynamics::FF),
-          6 => Change::Gradual.new(Dynamics::MF,2),
-          14 => Change::Immediate.new(Dynamics::PP),
-        }
-      )
-    }
-    @prog = Program.new([0...3,4...7,1...20,17..."45/2".to_r])
-    tcs = {
-      0 => Change::Immediate.new(120),
-      4 => Change::Gradual.new(60,2),
-      11 => Change::Immediate.new(110)
-    }
-    @score = Score::Unmeasured.new(120,
-      parts: @parts,
-      program: @prog,
-      tempo_changes: tcs,
-    )
-  end
-
-  describe '#note_offsets' do
-    before(:all){ @noffs = @score.note_offsets }
-    
-    it 'should return an already-sorted array' do
-      @noffs.should eq @noffs.sort
-    end
-    
-    it 'should start with offset from start tempo/dynamic' do
-      @noffs[0].should eq(0)
-    end
-    
-    it 'should include offsets from tempo changes' do
-      @score.tempo_changes.each do |noff,change|
-        @noffs.should include(noff)
-        @noffs.should include(noff + change.duration)
-      end
-    end
-    
-    it "should include offsets from each part's dynamic changes" do
-      @score.parts.values.each do |part|
-        part.dynamic_changes.each do |noff,change|
-          @noffs.should include(noff)
-          change.offsets(noff).each {|offset| @noffs.should include(offset) }
-        end
-      end
-    end
-    
-    it 'should include offsets from program segments' do
-      @score.program.segments.each do |seg|
-        @noffs.should include(seg.first)
-        @noffs.should include(seg.last)
-      end
-    end
-  end
-  
-  describe '#to_timed' do
-    it 'should use UnmeasuredScoreConverter#convert_score' do
-      nscore1 = @score.to_timed(200)
-      nscore2 = UnmeasuredScoreConverter.new(@score,200).convert_score
-      nscore1.should eq(nscore2)
-    end
-  end
-end

data/spec/notation/conversion/unmeasured_score_converter_spec.rb

@@ -1,116 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe UnmeasuredScoreConverter do
-  describe '#initialize' do
-    context 'current score is invalid' do
-      it 'should raise NotValidError' do
-        score = Score::Unmeasured.new(-1)
-        expect { UnmeasuredScoreConverter.new(score,200) }.to raise_error(NotValidError)
-      end
-    end
-  end
-  
-  describe '#convert_parts' do
-    before :each do
-      @changeA = Change::Immediate.new(Dynamics::PP)
-      @changeB = Change::Gradual.new(Dynamics::F, 2)
-      @score = Score::Unmeasured.new(120,
-        parts: {
-          "normal" => Part.new(Dynamics::MP,
-            dynamic_changes: { 1 => @changeA, 3 => @changeB },
-            notes: "/4C2 /8D2 /8E2 /2C2".to_notes * 4),
-          "empty" => Part.new(Dynamics::PP)
-        }
-      )
-      @parts = UnmeasuredScoreConverter.new(@score,200).convert_parts
-    end
-    
-    it 'should return Hash with original part names' do
-      @parts.should be_a Hash
-      @parts.keys.sort.should eq(@score.parts.keys.sort)
-    end
-    
-    it 'should convert part dynamic change offsets from note-based to time-based' do
-      part = @parts["normal"]
-      part.dynamic_changes.keys.sort.should eq([2,6])
-      change = part.dynamic_changes[2.0]
-      change.value.should eq(@changeA.value)
-      change.duration.should eq(0)
-      change = part.dynamic_changes[6.0]
-      change.value.should eq(@changeB.value)
-      change.duration.should eq(4.0)
-    end
-    
-    it 'should convert note durations to time durations' do
-      part = @parts["normal"]
-      part.notes.map {|x| x.duration }.should eq([0.5,0.25,0.25,1]*4)
-    end
-    
-    context 'gradual changes with positive elapsed and/or remaining' do
-      it 'should change elapsed and remaining so they reflect time-based duration' do
-        score = Score::Unmeasured.new(120, parts: {
-          "abc" => Part.new(Dynamics::P, dynamic_changes: {
-              2 => Change::Gradual.new(Dynamics::F,2,1,3),
-              7 => Change::Gradual.new(Dynamics::F,1,4,5)
-          })
-        })
-        converter = UnmeasuredScoreConverter.new(score,200)
-        parts = converter.convert_parts
-        dcs = parts["abc"].dynamic_changes
-        
-        dcs.keys.should eq([4,14])
-        dcs[4.0].should eq(Change::Gradual.new(Dynamics::F,4,2,6))
-        dcs[14.0].should eq(Change::Gradual.new(Dynamics::F,2,8,10))
-      end
-    end
-  end
-  
-  describe '#convert_program' do
-    before :each do
-      @prog = Program.new([0...4,2...5])
-      @score = Score::Unmeasured.new(120, program: @prog)
-      @converter = UnmeasuredScoreConverter.new(@score,200)
-      @prog2 = @converter.convert_program
-    end
-    
-    it 'should return Program with same number of segments' do
-      @prog2.should be_a Program
-      @prog2.segments.size.should eq(@prog.segments.size)
-    end
-  
-    it 'should convert program segments offsets from note-based to time-based' do
-      prog = @prog2
-      prog.segments[0].first.should eq(0)
-      prog.segments[0].last.should eq(8)
-      prog.segments[1].first.should eq(4)
-      prog.segments[1].last.should eq(10)
-    end
-  end
-  
-  describe '#convert_score' do    
-    it 'should return an timed score' do
-      score = Score::Unmeasured.new(120)
-      converter = UnmeasuredScoreConverter.new(score,200)
-      converter.convert_score.should be_a Score::Timed
-    end
-  
-    it 'should use output from convert_program' do
-      prog = Program.new([0...4,2...5])
-      score = Score::Unmeasured.new(120, program: prog)
-      converter = UnmeasuredScoreConverter.new(score,200)
-      nscore = converter.convert_score
-      nscore.program.should eq(converter.convert_program)
-    end
-    
-    it 'should use output from convert_parts' do
-      changeA = Change::Immediate.new(Dynamics::PP)
-      changeB = Change::Gradual.new(Dynamics::F, 2)
-      score = Score::Unmeasured.new(120,
-        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
-      )
-      converter = UnmeasuredScoreConverter.new(score,200)
-      nscore = converter.convert_score
-      nscore.parts.should eq(converter.convert_parts)
-    end
-  end
-end