musicality 0.2.0 → 0.3.0

data/spec/notation/conversion/score_converter_spec.rb

@@ -0,0 +1,246 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe ScoreConverter::TempoBased do
+  
+end
+
+describe ScoreConverter::Measured do
+  describe '#initialize' do
+    context 'current score is invalid' do
+      it 'should raise NotValidError' do
+        score = Score::Measured.new(1, 120)
+        expect { ScoreConverter::Measured.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.linear(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 = ScoreConverter::Measured.new(@score,200).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 = ScoreConverter::Measured.new(@score,200).convert_parts
+      parts.should have_key("simple")
+      part = parts["simple"]
+      part.dynamic_changes.keys.sort.should eq([2,6])
+      change = part.dynamic_changes[2.0]
+      change.end_value.should eq(@changeA.end_value)
+      change = part.dynamic_changes[6.0]
+      change.end_value.should eq(@changeB.end_value)
+      change.duration.should eq(4)
+      
+      #@score.start_meter = THREE_FOUR
+      #parts = ScoreConverter::Measured.new(@score,200).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.end_value.should eq(@changeA.end_value)
+      #change.duration.should eq(0)
+      #change = part.dynamic_changes[Rational(9,4)]
+      #change.end_value.should eq(@changeB.end_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.linear(Dynamics::F,2,1,3),
+    #          7 => Change::Gradual.linear(Dynamics::F,1,4,5)
+    #      })
+    #    })
+    #    converter = ScoreConverter::Measured.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.linear(Dynamics::F,Rational(6,4),Rational(3,4),Rational(9,4)))
+    #    dcs[Rational(21,4)].should eq(Change::Gradual.linear(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 = ScoreConverter::Measured.new(@score,200)
+    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 = ScoreConverter::Measured.new(@score,200).convert_program
+      prog.segments.size.should eq(2)
+      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)
+      
+      @score.start_meter = THREE_FOUR
+      prog = ScoreConverter::Measured.new(@score,200).convert_program
+      prog.segments.size.should eq(2)
+      prog.segments[0].first.should eq(0)
+      prog.segments[0].last.should eq(6)
+      prog.segments[1].first.should eq(3)
+      prog.segments[1].last.should eq(7.5)
+    end
+  end
+  
+  describe '#convert_score' do    
+    it 'should return a timed score' do
+      score = Score::Measured.new(FOUR_FOUR, 120)
+      converter = ScoreConverter::Measured.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::Measured.new(FOUR_FOUR, 120, program: prog)
+      converter = ScoreConverter::Measured.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.linear(Dynamics::F, 2)
+      score = Score::Measured.new(FOUR_FOUR, 120,
+        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
+      )
+      converter = ScoreConverter::Measured.new(score,200)
+      nscore = converter.convert_score
+      nscore.parts.should eq(converter.convert_parts)
+    end
+  end  
+end
+
+describe ScoreConverter::Unmeasured do
+  describe '#initialize' do
+    context 'current score is invalid' do
+      it 'should raise NotValidError' do
+        score = Score::Unmeasured.new(-1)
+        expect { ScoreConverter::Unmeasured.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.linear(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 = ScoreConverter::Unmeasured.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.end_value.should eq(@changeA.end_value)
+      change = part.dynamic_changes[6.0]
+      change.end_value.should eq(@changeB.end_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 'trimmed, gradual changes' do
+      it 'should change preceding 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.linear(Dynamics::F,4).to_trimmed(2,1),
+              7 => Change::Gradual.linear(Dynamics::F,5).to_trimmed(1,3)
+          })
+        })
+        converter = ScoreConverter::Unmeasured.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.linear(Dynamics::F,8).to_trimmed(4,2))
+        dcs[14.0].should eq(Change::Gradual.linear(Dynamics::F,10).to_trimmed(2,6))
+      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 = ScoreConverter::Unmeasured.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 = ScoreConverter::Unmeasured.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 = ScoreConverter::Unmeasured.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.linear(Dynamics::F, 2)
+      score = Score::Unmeasured.new(120,
+        parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
+      )
+      converter = ScoreConverter::Unmeasured.new(score,200)
+      nscore = converter.convert_score
+      nscore.parts.should eq(converter.convert_parts)
+    end
+  end
+end

data/spec/notation/model/change_spec.rb

@@ -2,21 +2,17 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Change::Immediate do
   context '#initialize' do
-    it 'should set value to given' do
-      Change::Immediate.new(5).value.should eq 5
-    end
-    
-    it 'should set duration to 0' do
-      Change::Immediate.new(5).duration.should eq 0
+    it 'should set end value to given' do
+      Change::Immediate.new(5).end_value.should eq 5
     end
   end
     
   describe '==' do
-    it 'should return true if two immediate changes have the same value' do
+    it 'should return true if two immediate changes have the same end value' do
       Change::Immediate.new(5).should eq(Change::Immediate.new(5))
     end
     
-    it 'should return false if two immediate changes do not have the same value' do
+    it 'should return false if two immediate changes do not have the same end value' do
       Change::Immediate.new(5).should_not eq(Change::Immediate.new(4))
     end
   end
@@ -30,61 +26,168 @@ describe Change::Immediate do
 end
 
 describe Change::Gradual do
-  context '.new' do
-    it 'should set value to given value' do
-      Change::Gradual.new(5,2).value.should eq 5
+  context '#initialize' do
+    it 'should set end value and duration to given values' do
+      ch = Change::Gradual.new(5,2,Change::Gradual::LINEAR)
+      ch.end_value.should eq(5)
+      ch.duration.should eq(2)
     end
     
-    it 'should set duration to given impending duration' do
-      c = Change::Gradual.new(5,2)
-      c.duration.should eq 2
-      c.impending.should eq 2
+    it 'should set start_value to nil if not given' do
+      Change::Gradual.linear(5,2).start_value.should be nil
     end
     
-    it 'should set elapsed to 0 by default' do
-      Change::Gradual.new(5,2).elapsed.should eq 0
+    it 'should set start_value if given' do
+      Change::Gradual.linear(5,2, start_value: 3).start_value.should eq(3)
     end
     
-    it 'should set remaining to 0 by default' do
-      Change::Gradual.new(5,2).remaining.should eq 0
+    it 'should raise NonPositiveError if duration is <= 0' do
+      expect { Change::Gradual.new(11,0,Change::Gradual::LINEAR) }.to raise_error(NonPositiveError)
+      expect { Change::Gradual.new(11,-1,Change::Gradual::LINEAR) }.to raise_error(NonPositiveError)
+    end
+  end
+  
+  describe '#relative?' do
+    context 'start_value is nil' do
+      it 'should return true' do
+        Change::Gradual.linear(25,3).relative?.should be true
+      end
     end
     
-    it 'should compute total_duration to be elapsed + impending + remaining' do
-      Change::Gradual.new(100,7,2,3).total_duration.should eq(12)
+    context 'start_value is not nil' do
+      it 'should return false' do
+        Change::Gradual.linear(25,3, start_value: 10).relative?.should be false
+      end
     end
+  end
+  
+  context '.linear' do
+    before(:all){ @change = Change::Gradual.linear(55,20, start_value: 25) }
     
-    it 'should raise NonPositiveError if impending is <= 0' do
-      expect { Change::Gradual.new(11,0) }.to raise_error(NonPositiveError)
-      expect { Change::Gradual.new(11,-1) }.to raise_error(NonPositiveError)
+    it 'should assign end_value, duration, and start_value as normal' do
+      @change.end_value.should eq(55)
+      @change.duration.should eq(20)
+      @change.start_value.should eq(25)
     end
+    
+    it 'should set transition to linear' do
+      @change.transition.should eq(Change::Gradual::LINEAR)
+    end
+  end
 
-    it 'should raise NegativeError if elapsed is < 0' do
-      expect { Change::Gradual.new(11,1,-1) }.to raise_error(NegativeError)
+  context '.sigmoid' do
+    before(:all){ @change = Change::Gradual.sigmoid(55,20, start_value: 25) }
+    
+    it 'should assign end_value, duration, and start_value as normal' do
+      @change.end_value.should eq(55)
+      @change.duration.should eq(20)
+      @change.start_value.should eq(25)
     end
     
-    it 'should raise NegativeError if remaining is < 0' do
-      expect { Change::Gradual.new(11,1,0,-1) }.to raise_error(NegativeError)
+    it 'should set transition to SIGMOID' do
+      @change.transition.should eq(Change::Gradual::SIGMOID)
     end
   end
-    
+  
   describe '==' do
-    it 'should return true if two gradual changes have the same value and duration' do
-      Change::Gradual.new(5,2).should eq(Change::Gradual.new(5,2))
+    context 'two gradual changes have the same end value, duration, and start value' do
+      it 'should return true' do
+        Change::Gradual.linear(5,2).should eq(Change::Gradual.linear(5,2))
+        Change::Gradual.linear(5,2,start_value:0).should eq(Change::Gradual.linear(5,2,start_value:0))
+      end
     end
     
-    it 'should return false if two gradual changes do not have the same value' do
-      Change::Gradual.new(5,2).should_not eq(Change::Gradual.new(4,2))
+    context 'two gradual changes do not have the same end value' do
+      it 'should return false' do
+        Change::Gradual.linear(5,2).should_not eq(Change::Gradual.linear(4,2))
+      end
     end
     
-    it 'should return false if two gradual changes do not have the same duration' do
-      Change::Gradual.new(5,2).should_not eq(Change::Gradual.new(5,1))
+    context 'two gradual changes do not have the same duration' do
+      it 'should return false' do
+        Change::Gradual.linear(5,2).should_not eq(Change::Gradual.linear(5,1))
+      end
+    end
+    
+    context 'two gradual changes do not have the start value' do
+      it 'should return false' do
+        Change::Gradual.linear(5,2, start_value: 3).should_not eq(Change::Gradual.linear(5,1))
+      end
     end
   end
   
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
-      c = Change::Gradual.new(4,2)
+      c = Change::Gradual.linear(4,2)
       YAML.load(c.to_yaml).should eq c
     end
   end
 end
+
+describe Change::Gradual::Trimmed do
+  it 'should be a Change::Gradual' do
+    Change::Gradual::Trimmed.new(35,1,Change::Gradual::LINEAR,preceding: 0, remaining: 0.5).should be_a Change::Gradual
+  end
+  
+  describe '.linear' do
+    before(:all){ @change = Change::Gradual::Trimmed.linear(55,20,preceding:5,remaining:6) }
+    
+    it 'should assign end_value, duration, preceding, and remaining as normal' do
+      @change.end_value.should eq(55)
+      @change.duration.should eq(20)
+      @change.preceding.should eq(5)
+      @change.remaining.should eq(6)
+    end
+    
+    it 'should set transition to linear' do
+      @change.transition.should eq(Change::Gradual::LINEAR)
+    end
+  end
+  
+  describe '.sigmoid' do
+    before(:all){ @change = Change::Gradual::Trimmed.sigmoid(55,20,preceding:5,remaining:6) }
+    
+    it 'should assign end_value, duration, preceding, and remaining as normal' do
+      @change.end_value.should eq(55)
+      @change.duration.should eq(20)
+      @change.preceding.should eq(5)
+      @change.remaining.should eq(6)
+    end
+    
+    it 'should set transition to SIGMOID' do
+      @change.transition.should eq(Change::Gradual::SIGMOID)
+    end
+  end
+  
+  it 'should raise NegativeError if preceding is < 0' do
+    expect { Change::Gradual::Trimmed.linear(11,1,preceding: -1,remaining: 0.5) }.to raise_error(NegativeError)
+  end
+
+  it 'should raise NonPositiveError if remaining is <= 0' do
+    expect { Change::Gradual::Trimmed.linear(11,3,preceding: 1,remaining: 0) }.to raise_error(NonPositiveError)
+    expect { Change::Gradual::Trimmed.linear(11,3,preceding: 1,remaining: -1) }.to raise_error(NonPositiveError)
+  end
+  
+  describe '#untrim' do
+    before :all do
+      @trimmed = Change::Gradual.linear(51,12).trim(2,2)
+      @untrimmed = @trimmed.untrim
+    end
+    
+    it 'should return a Change::Gradual' do
+      @untrimmed.should be_a Change::Gradual
+    end
+    
+    it 'should keep end_value, duration, and transition' do
+      @untrimmed.end_value.should eq(@trimmed.end_value)
+      @untrimmed.duration.should eq(@trimmed.duration)
+      @untrimmed.transition.should eq(@trimmed.transition)
+    end
+  end
+  
+  describe '#trailing' do
+    it 'should return the amount of transition unused at the end' do
+      Change::Gradual.linear(41,19).trim(4,9).trailing.should eq(9)
+    end
+  end
+end

data/spec/notation/model/part_spec.rb

@@ -13,7 +13,7 @@ describe Part do
       p.start_dynamic.should eq Dynamics::PPP
       
       notes = [Note::whole([A2]), Note::half]
-      dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.new(Dynamics::MF,1) }
+      dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.sigmoid(Dynamics::MF,1) }
       p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs)
       p.notes.should eq notes
       p.dynamic_changes.should eq dcs
@@ -38,7 +38,7 @@ describe Part do
       #  :dynamic_changes => { -0.2 => Change::Immediate.new(0.5) }],
       'dynamic change values outside 0..1' => [
         0.5, :notes => [ Note::whole ],
-        :dynamic_changes => { 0.2 => Change::Immediate.new(-0.01), 0.3 => Change::Gradual.new(1.01,0.2) }],
+        :dynamic_changes => { 0.2 => Change::Immediate.new(-0.01), 0.3 => Change::Gradual.linear(1.01,0.2) }],
       'notes with 0 duration' => [ 0.5, :notes => [ Note.new(0) ]],
       'notes with negative duration' => [ 0.5, :notes => [ Note.new(-1) ]],
     }.each do |context_str, args|
@@ -56,7 +56,7 @@ describe Part do
         :notes => [ Note::whole([C4]), Note::quarter ],
         :dynamic_changes => {
           0.5 => Change::Immediate.new(Dynamics::MP),
-          1.2 => Change::Gradual.new(Dynamics::FF, 0.05) } ],
+          1.2 => Change::Gradual.linear(Dynamics::FF, 0.05) } ],
     }.each do |context_str, args|
       context context_str do
         it 'should return true' do

data/spec/notation/model/score_spec.rb

@@ -138,7 +138,7 @@ describe Score::Measured do
     {
       'valid start tempo' => [ FOUR_FOUR, 40 ],
       'valid tempo changes' => [ FOUR_FOUR, 30,
-        :tempo_changes => { 1 => Change::Gradual.new(40, 2), 2 => Change::Immediate.new(50) } ],
+        :tempo_changes => { 1 => Change::Gradual.linear(40, 2), 2 => Change::Immediate.new(50) } ],
       'valid meter changes' => [ FOUR_FOUR, 120,
         :meter_changes => { 1 => Change::Immediate.new(TWO_FOUR) } ],
       'valid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Samples::SAMPLE_PART }],
@@ -161,7 +161,7 @@ describe Score::Measured do
       'non-meter values in meter changes' => [ FOUR_FOUR, 120,
         :meter_changes => { 1 => Change::Immediate.new(5) } ],
       'non-immediate meter change' => [ FOUR_FOUR, 120,
-        :meter_changes => { 1 => Change::Gradual.new(TWO_FOUR,1) } ],
+        :meter_changes => { 1 => Change::Gradual.linear(TWO_FOUR,1) } ],
       'non-integer meter change offset' => [ FOUR_FOUR, 120,
         :meter_changes => { 1.1 => Change::Immediate.new(TWO_FOUR) } ],
       'invalid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Part.new(-0.1) }],
@@ -216,7 +216,7 @@ describe Score::Unmeasured do
     {
       'valid start tempo' => [ 40 ],
       'valid tempo changes' => [ 30,
-        :tempo_changes => { 1 => Change::Gradual.new(40, 2), 2 => Change::Immediate.new(50) } ],
+        :tempo_changes => { 1 => Change::Gradual.linear(40, 2), 2 => Change::Immediate.new(50) } ],
       'valid part' => [ 30, :parts => { "piano" => Samples::SAMPLE_PART }],
       'valid program' => [ 30, :program => Program.new([0..2,0..2]) ]
     }.each do |context_str,args|
@@ -231,7 +231,7 @@ describe Score::Unmeasured do
       'start tempo valid is zero' => [ 0 ],
       'start tempo valid is negative' => [ -1 ],
       'tempo change value is not a valid value' => [ 30,
-        :tempo_changes => { 1 => Change::Gradual.new(-1,1) } ],
+        :tempo_changes => { 1 => Change::Gradual.linear(-1,1) } ],
       'invalid part' => [ 30, :parts => { "piano" => Part.new(-0.1) }],
       'invalid program' => [ 30, :program => Program.new([2..0]) ],
     }.each do |context_str,args|