musicality 0.3.0 → 0.5.0

data/spec/notation/model/note_spec.rb

@@ -120,18 +120,21 @@ describe Note do
         [[C2],{}],
         [[A5,D6],{ A5 => Link::Tie.new }],
         [[C5,E6,Gb2],{ C5 => Link::Glissando.new(D5) }],
-        [[A5,D6],{ A5 => Link::Legato.new(B5), D6 => Link::Slur.new(E6) }],
         [[C5,E6,Gb2],{ C5 => Link::Portamento.new(D5), Gb2 => Link::Tie.new }],
       ]
       
       notes = []
       durations.each do |d|
-        articulations.each do |art|
-          pitches_links_sets.each do |pitches_links_set|
-            pitches,links = pitches_links_set
-            [true,false].each do |acc|
-              notes.push Note.new(d, pitches, articulation: art, links: links, accented: acc)
+        pitches_links_sets.each do |pitches_links_set|
+          pitches,links = pitches_links_set
+          if pitches.any?
+            articulations.each do |art|
+              [true,false].each do |acc|
+                notes.push Note.new(d, pitches, articulation: art, links: links, accented: acc)
+              end
             end
+          else
+            notes.push Note.new(d)
           end
         end
       end

data/spec/notation/model/pitch_spec.rb

@@ -62,13 +62,36 @@ describe Pitch do
   end
   
   describe '#transpose' do
-    it 'should add the given interval to total semitones' do
+    it 'should make a new pitch, adding the given interval to total semitones' do
       [0,1,2,5,12,13,-1,-2,-5,-12,-13].each do |interval|
         pitch = Eb3.transpose(interval)
+        pitch.should_not be Eb3
         pitch.diff(Eb3).should eq(interval)
       end
     end
   end
+  
+  describe '#+' do
+    it 'should produce same result as #transpose' do
+      [0,1,2,5,12,13,-1,-2,-5,-12,-13].each do |interval|
+        pitch = Eb3 + interval
+        pitch.should_not be Eb3
+        pitch2 = Eb3.transpose(interval)
+        pitch.should eq(pitch2)
+      end
+    end
+  end
+
+  describe '#-' do
+    it 'should produce same result as #transpose, with negative interval' do
+      [0,1,2,5,12,13,-1,-2,-5,-12,-13].each do |interval|
+        pitch = Eb3 - interval
+        pitch.should_not be Eb3
+        pitch2 = Eb3.transpose(-interval)
+        pitch.should eq(pitch2)
+      end
+    end
+  end
 
   describe '.total_semitones' do
     it 'should convert to whole/fractional total semitones value' do

data/spec/notation/model/score_spec.rb

@@ -4,14 +4,14 @@ describe Score do
   describe '#collated?' do
     context 'has program with more than one segment' do
       it 'should return false' do
-        score = Score.new(program: Program.new([0..2,0..2]))
+        score = Score.new(program: [0..2,0..2])
         score.collated?.should be false
       end      
     end
     
     context 'has program with 0 segments' do
       it 'should return false' do
-        score = Score.new(program: Program.new([]))
+        score = Score.new(program: [])
         score.collated?.should be false        
       end
     end
@@ -19,14 +19,14 @@ describe Score do
     context 'has program with 1 segment' do
       context 'program segment starts at 0' do
         it 'should return true' do
-          score = Score.new(program: Program.new([0..2]))
+          score = Score.new(program: [0..2])
           score.collated?.should be true
         end
       end
       
       context 'program segment does not start at 0' do
         it 'should return false' do
-          score = Score.new(program: Program.new([1..2]))
+          score = Score.new(program: [1..2])
           score.collated?.should be false
         end
       end
@@ -48,6 +48,32 @@ describe Score do
       end
     end
   end
+  
+  describe '#valid?' do
+    context 'non-Range objects' do
+      it 'should return false' do
+        Score.new(program: [1,2,3]).should_not be_valid
+      end
+    end
+    
+    context 'increasing, positive segments' do
+      it 'should return true' do
+        Score.new(program: [0..2,1..2,0..4]).should be_valid
+      end
+    end
+    
+    context 'decreasing, positive segments' do
+      it 'should return false' do
+        Score.new(program: [2..0,2..1,04..0]).should be_invalid
+      end
+    end
+
+    context 'increasing, negative segments' do
+      it 'should return false' do
+        Score.new(program: [-1..2,-2..0,-2..2]).should be_invalid
+      end
+    end
+  end
 end
 
 describe Score::Measured do
@@ -55,7 +81,7 @@ describe Score::Measured do
     it 'should use empty containers for parameters not given' do
       s = Score::Measured.new(FOUR_FOUR,120)
       s.parts.should be_empty
-      s.program.segments.should be_empty
+      s.program.should be_empty
     end
     
     it 'should assign given parameters' do
@@ -65,7 +91,7 @@ describe Score::Measured do
       s.start_tempo.should eq 120
       
       parts = { "piano (LH)" => Samples::SAMPLE_PART }
-      program = Program.new [0...0.75, 0...0.75]
+      program = [0...0.75, 0...0.75]
       mcs = { 1 => Change::Immediate.new(THREE_FOUR) }
       tcs = { 1 => Change::Immediate.new(100) }
       
@@ -132,6 +158,21 @@ describe Score::Measured do
         ).measures_long.should eq(3.5)
       end
     end
+    
+    context 'given specific note duration' do
+      it 'should change the given note duration to measures' do
+        score = Score::Measured.new(TWO_FOUR, 120,
+            meter_changes: {
+              2 => Change::Immediate.new(FOUR_FOUR),
+              4 => Change::Immediate.new(SIX_EIGHT)
+        })
+        
+        { 1 => 2, 1.5 => 2.5, 2 => 3, 3 => 4, 3.75 => 5
+        }.each do |note_dur, meas_dur|
+          score.measures_long(note_dur).should eq(meas_dur)
+        end
+      end
+    end
   end
 
   describe '#valid?' do
@@ -142,7 +183,7 @@ describe Score::Measured do
       'valid meter changes' => [ FOUR_FOUR, 120,
         :meter_changes => { 1 => Change::Immediate.new(TWO_FOUR) } ],
       'valid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Samples::SAMPLE_PART }],
-      'valid program' => [ FOUR_FOUR, 120, :program => Program.new([0..2,0..2]) ]
+      'valid program' => [ FOUR_FOUR, 120, :program => [0..2,0..2] ]
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
@@ -165,7 +206,7 @@ describe Score::Measured do
       '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) }],
-      'invalid program' => [ FOUR_FOUR, 120, :program => Program.new([2..0]) ],
+      'invalid program' => [ FOUR_FOUR, 120, :program => [2..0] ],
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do
@@ -181,7 +222,7 @@ describe Score::Unmeasured do
     it 'should use empty containers for parameters not given' do
       s = Score::Unmeasured.new(30)
       s.parts.should be_empty
-      s.program.segments.should be_empty
+      s.program.should be_empty
     end
     
     it 'should assign given parameters' do
@@ -189,7 +230,7 @@ describe Score::Unmeasured do
       s.start_tempo.should eq(30)
       
       parts = { "piano (LH)" => Samples::SAMPLE_PART }
-      program = Program.new [0...0.75, 0...0.75]
+      program = [0...0.75, 0...0.75]
       tcs = { 1 => Change::Immediate.new(40) }
       
       s = Score::Unmeasured.new(30,
@@ -218,7 +259,7 @@ describe Score::Unmeasured do
       'valid tempo changes' => [ 30,
         :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]) ]
+      'valid program' => [ 30, :program => [0..2,0..2] ]
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
@@ -233,7 +274,7 @@ describe Score::Unmeasured do
       'tempo change value is not a valid value' => [ 30,
         :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]) ],
+      'invalid program' => [ 30, :program => [2..0] ],
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do
@@ -249,12 +290,12 @@ describe Score::Timed do
     it 'should use empty containers for parameters not given' do
       s = Score::Timed.new
       s.parts.should be_empty
-      s.program.segments.should be_empty
+      s.program.should be_empty
     end
     
     it 'should assign given parameters' do
       parts = { "piano (LH)" => Samples::SAMPLE_PART }
-      program = Program.new [0...0.75, 0...0.75]
+      program = [0...0.75, 0...0.75]
       
       s = Score::Timed.new(parts: parts, program: program)
       s.parts.should eq parts
@@ -274,7 +315,7 @@ describe Score::Timed do
   describe '#valid?' do
     {
       'valid part' => [ :parts => { "piano" => Samples::SAMPLE_PART }],
-      'valid program' => [ :program => Program.new([0..2,0..2]) ]
+      'valid program' => [ :program => [0..2,0..2] ]
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
@@ -285,7 +326,7 @@ describe Score::Timed do
     
     {
       'invalid part' => [ :parts => { "piano" => Part.new(-0.1) }],
-      'invalid program' => [ :program => Program.new([2..0]) ],
+      'invalid program' => [ :program => [2..0] ],
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do

data/spec/notation/packing/score_packing_spec.rb

@@ -2,17 +2,26 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 measured_score = Score::Measured.new(FOUR_FOUR,120) do |s|
   s.meter_changes[1] = Change::Immediate.new(THREE_FOUR)
-  s.program = Program.new([0...2, 0...2,2...4,0...2])
+  s.meter_changes[7] = Change::Immediate.new(SIX_EIGHT)
+  
+  s.tempo_changes[2] = Change::Immediate.new(100)
+  s.tempo_changes[4] = Change::Gradual.linear(70,2)
+  s.tempo_changes[9] = Change::Gradual.sigmoid(99,5).trim(2,2)
+  
+  s.program += [0...2, 0...2,2...4,0...2]
   s.parts["lead"] = Part.new(Dynamics::MF) do |p|
     riff = "/6Bb3 /4 /12Db4= /6Db4= /36Db4 /36Eb4 /36Db4 /6Ab3 /12Db4 \
-            /6Bb3 /4 /12Db4= /4Db4=                      /8=Db4 /8C4".to_notes
+            /6Bb3 /4 /12Db4= /4Db4=                      /8Db4= /8C4".to_notes
     p.notes = riff + riff.map {|n| n.transpose(2) }
+    p.dynamic_changes[1] = Change::Gradual.linear(Dynamics::F,2)
   end
   
   s.parts["bass"] = Part.new(Dynamics::MP) do |p|
     riff = "/6Bb2 /4 /3Ab2 /6F2 /12Ab2 \
             /6Bb2 /4 /3Ab2 /4Ab2".to_notes
     p.notes = riff + riff.map {|n| n.transpose(2) }
+    p.dynamic_changes[1] = Change::Immediate.new(Dynamics::F)
+    p.dynamic_changes[3] = Change::Gradual.sigmoid(Dynamics::PP,4).trim(1,1)
   end
 end
 
@@ -26,203 +35,162 @@ timed_score = Score::Timed.new do |s|
   s.parts = measured_score.parts
 end
 
-describe Score::Measured do
-  before :all do
-    @score = measured_score
-    @h = @score.pack
-  end
-  
-  describe '#pack' do
-    it 'should return a hash' do
-      @h.should be_a Hash
+[ measured_score, unmeasured_score, timed_score ].each do |score|
+  describe score.class do
+    before :all do
+      @score = score
+      @h = @score.pack
     end
     
-    it 'should return a hash with keys: "type","parts", "start_meter", ...' do
-      ["type","parts","start_tempo","tempo_changes","program","start_meter","meter_changes"].each do |key|
-        @h.should have_key(key)
+    describe '#pack' do
+      it 'should return a hash' do
+        @h.should be_a Hash
       end
-    end
-    
-    it 'should set "type" key to "Measured"' do
-      @h["type"].should eq("Measured")
-    end
-    
-    it 'should pack start meter as a string' do
-      @h['start_meter'].should be_a String
-    end
-    
-    it 'should pack meter changes as whatver type Change#pack returns' do
-      @h['meter_changes'].each do |offset,packed_v|
-        change_v = @score.meter_changes[offset]
-        t = change_v.pack.class
-        packed_v.should be_a t
+      
+      it 'should return a hash with keys: "type","parts", and "program"' do
+        ["type","parts","program"].each do |key|
+          @h.should have_key(key)
+        end
       end
-    end
-
-    it 'should pack meter change end values as strings' do
-      @h['meter_changes'].each do |offset,packed_v|
-        packed_v["end_value"].should be_a String
+      
+      it 'should pack program as an array with same size' do
+        @h['program'].should be_a Array
+        @h['program'].size.should eq(@score.program.size)
       end
-    end
-    
-    it 'should pack start tempo as numeric' do
-      @h['start_tempo'].should be_a Numeric
-    end
-    
-    it 'should pack tempo changes as whatver type Change#pack returns' do
-      @h['tempo_changes'].each do |offset,packed_v|
-        change_v = @score.tempo_changes[offset]
-        t = change_v.pack.class
-        packed_v.should be_a t
+      
+      it 'should pack program segments as strings' do
+        @h['program'].each {|x| x.should be_a String }
       end
-    end
-    
-    it 'should pack tempo change values as numerics' do
-      @h['tempo_changes'].each do |offset,packed_v|
-        packed_v[0].should be_a Numeric
+  
+      it 'should pack parts as hash' do
+        @h['parts'].should be_a Hash
+      end
+      
+      it 'should pack parts as whatever Part#pack returns' do
+        @score.parts.each do |name,part|
+          packing = part.pack
+          @h['parts'][name].should eq packing
+        end
       end
     end
     
-    it 'should pack program as whatever type Program#pack returns' do
-      t = @score.program.pack.class
-      @h['program'].should be_a t
-    end
-    
-    it 'should pack program segments as strings' do
-      @h['program'].each {|x| x.should be_a String }
-    end
-
-    it 'should pack parts as hash' do
-      @h['parts'].should be_a Hash
-    end
-    
-    it 'should pack parts as whatever Part#pack returns' do
-      @score.parts.each do |name,part|
-        packing = part.pack
-        @h['parts'][name].should eq packing
+    describe '.unpack' do
+      before :all do
+        @score2 = score.class.unpack @h
+      end
+      
+      it "should return a #{score.class}" do
+        @score2.should be_a score.class
+      end
+      
+      it 'should successfuly unpack the parts' do
+        @score2.parts.should eq @score.parts
+      end
+      
+      it 'should successfuly unpack the program' do
+        @score2.program.should eq @score.program
       end
     end
   end
-  
-  describe '.unpack' do
+end
+
+[ measured_score, unmeasured_score ].each do |score|
+  describe score.class do
     before :all do
-      @score2 = Score::Measured.unpack @h
-    end
-    
-    it 'should return a Score::Measured' do
-      @score2.should be_a Score::Measured
-    end
-    
-    it 'should successfuly unpack the parts' do
-      @score2.parts.should eq @score.parts
+      @score = score
+      @h = @score.pack
     end
     
-    it 'should successfuly unpack the start meter' do
-      @score2.start_meter.should eq @score.start_meter
-    end
-
-    it 'should successfuly unpack the start tempo' do
-      @score2.start_tempo.should eq @score.start_tempo
-    end
+    describe '#pack' do
+      it 'should return a hash with keys: "start_tempo" and "tempo_changes"' do
+        ["start_tempo","tempo_changes"].each {|key| @h.should have_key(key) }
+      end
 
-    it 'should successfuly unpack the meter changes' do
-      @score2.meter_changes.should eq @score.meter_changes
-    end
+      it 'should pack start tempo as numeric' do
+        @h['start_tempo'].should be_a Numeric
+      end
 
-    it 'should successfuly unpack the tempo changes' do
-      @score2.tempo_changes.should eq @score.tempo_changes
+      it 'should pack tempo changes as a hash' do
+        @h['tempo_changes'].should be_a Hash
+      end
+      
+      it 'should pack tempo changes values using Change#pack' do
+        @h['tempo_changes'].each do |offset,packed_v|
+          change = @score.tempo_changes[offset]
+          packed_v.should eq(change.pack)
+        end
+      end
     end
-
-    it 'should successfuly unpack the program' do
-      @score2.program.should eq @score.program
+    
+    describe '.unpack' do
+      before :all do
+        @score2 = score.class.unpack @h
+      end
+      
+      it 'should successfuly unpack the start tempo' do
+        @score2.start_tempo.should eq @score.start_tempo
+      end
+      
+      it 'should successfuly unpack the tempo changes' do
+        @score2.tempo_changes.should eq @score.tempo_changes
+      end
     end
   end
 end
 
-describe Score::Unmeasured do
+describe Score::Measured do
   before :all do
-    @score = unmeasured_score
+    @score = measured_score
     @h = @score.pack
   end
   
-  describe '#pack' do
-    it 'should return a hash' do
-      @h.should be_a Hash
-    end
-    
-    it 'should return a hash with keys: "type","parts", "program", ...' do
-      ["type","parts","start_tempo","tempo_changes","program"].each do |key|
-        @h.should have_key(key)
-      end
-    end
-    
-    it 'should set "type" key to "Unmeasured"' do
-      @h["type"].should eq("Unmeasured")
-    end
-    
-    it 'should pack start tempo as numeric' do
-      @h['start_tempo'].should be_a Numeric
+  describe '#pack' do    
+    it 'should return a hash with keys: "start_meter" and "meter_changes"' do
+      ["start_meter","meter_changes"].each { |key| @h.should have_key(key) }
     end
     
-    it 'should pack tempo changes as whatver type Change#pack returns' do
-      @h['tempo_changes'].each do |offset,packed_v|
-        change_v = @score.tempo_changes[offset]
-        t = change_v.pack.class
-        packed_v.should be_a t
-      end
+    it 'should set "type" key to "Measured"' do
+      @h["type"].should eq("Measured")
     end
     
-    it 'should pack tempo change values as numerics' do
-      @h['tempo_changes'].each do |offset,packed_v|
-        packed_v[0].should be_a Numeric
-      end
+    it 'should pack start meter as a string' do
+      @h['start_meter'].should be_a String
     end
 
-    it 'should pack program as whatever type Program#pack returns' do
-      t = @score.program.pack.class
-      @h['program'].should be_a t
-    end
-    
-    it 'should pack program segments as strings' do
-      @h['program'].each {|x| x.should be_a String }
+    it 'should pack meter changes values using Change#pack(:with => :to_s)' do
+      @h['meter_changes'].each do |offset,packed_v|
+        change = @score.meter_changes[offset]
+        packed_v.should eq(change.pack(:with => :to_s))
+      end
     end
 
-    it 'should pack parts as hash' do
-      @h['parts'].should be_a Hash
-    end
-    
-    it 'should pack parts as whatever Part#pack returns' do
-      @score.parts.each do |name,part|
-        packing = part.pack
-        @h['parts'][name].should eq packing
+    it 'should pack meter change end values as strings' do
+      @h['meter_changes'].each do |offset,packed_v|
+        packed_v["end_value"].should be_a String
       end
-    end
+    end    
   end
   
   describe '.unpack' do
     before :all do
-      @score2 = Score::Unmeasured.unpack @h
-    end
-    
-    it 'should return a Score::Unmeasured' do
-      @score2.should be_a Score::Unmeasured
-    end
-    
-    it 'should successfuly unpack the parts' do
-      @score2.parts.should eq @score.parts
+      @score2 = Score::Measured.unpack @h
     end
     
-    it 'should successfuly unpack the start tempo' do
-      @score2.start_tempo.should eq @score.start_tempo
+    it 'should successfuly unpack the start meter' do
+      @score2.start_meter.should eq @score.start_meter
     end
 
-    it 'should successfuly unpack the tempo changes' do
-      @score2.tempo_changes.should eq @score.tempo_changes
+    it 'should successfuly unpack the meter changes' do
+      @score2.meter_changes.should eq @score.meter_changes
     end
+  end
+end
 
-    it 'should successfuly unpack the program' do
-      @score2.program.should eq @score.program
-    end
+describe Score::Unmeasured do
+  describe '#pack' do
+    it 'should set "type" key to "Unmeasured"' do
+      unmeasured_score.pack["type"].should eq("Unmeasured")
+    end    
   end
 end
 
@@ -233,57 +201,9 @@ describe Score::Timed do
   end
   
   describe '#pack' do
-    it 'should return a hash' do
-      @h.should be_a Hash
-    end
-    
-    it 'should return a hash with keys: "type","parts", and "program"' do
-      ["type","parts","program"].each do |key|
-        @h.should have_key(key)
-      end
-    end
-    
     it 'should set "type" key to "Timed"' do
       @h["type"].should eq("Timed")
-    end
-    
-    it 'should pack program as whatever type Program#pack returns' do
-      t = @score.program.pack.class
-      @h['program'].should be_a t
-    end
-    
-    it 'should pack program segments as strings' do
-      @h['program'].each {|x| x.should be_a String }
-    end
-
-    it 'should pack parts as hash' do
-      @h['parts'].should be_a Hash
-    end
-    
-    it 'should pack parts as whatever Part#pack returns' do
-      @score.parts.each do |name,part|
-        packing = part.pack
-        @h['parts'][name].should eq packing
-      end
-    end
-  end
-  
-  describe '.unpack' do
-    before :all do
-      @score2 = Score::Timed.unpack @h
-    end
-    
-    it 'should return a Score::Timed' do
-      @score2.should be_a Score::Timed
-    end
-    
-    it 'should successfuly unpack the parts' do
-      @score2.parts.should eq @score.parts
-    end
-    
-    it 'should successfuly unpack the program' do
-      @score2.program.should eq @score.program
-    end
+    end    
   end
 end
 
@@ -291,10 +211,18 @@ describe Score do
   describe '.unpack' do
     [ timed_score, unmeasured_score, measured_score ].each do |score|
       context "given packing from a #{score.class} object" do
+        before :all do
+          @packing = score.pack
+          @score2 = Score.unpack(@packing)
+        end
+        
         it "should return a #{score.class} object equal to original" do
-          score2 = Score.unpack(score.pack)
-          score2.should be_a score.class
-          score2.should eq(score)
+          @score2.should be_a score.class
+          @score2.should eq(score)
+        end
+        
+        it "should return a score equal to what #{score.class}.unpack returns" do
+          @score2.should eq(score.class.unpack(@packing))
         end
       end
     end