musicality 0.10.1 → 0.11.0

data/lib/musicality/version.rb

@@ -1,3 +1,3 @@
 module Musicality
-  VERSION = "0.10.1"
+  VERSION = "0.11.0"
 end

data/musicality.gemspec

@@ -9,9 +9,11 @@ Gem::Specification.new do |spec|
   spec.authors       = ["James Tunnell"]
   spec.email         = ["jamestunnell@gmail.com"]
   spec.summary       = %q{Music notation, composition, and performance}
-  spec.description   = %q{The library is based around an abstract representation for music notation. \
-                          From here, functions are built up to make composing elaborate pieces in this notation representation more manageable. \
-                          Finally, music performance is supported by providing translation to common formats, like MIDI. }
+  spec.description   = "The library is based around an abstract representation "
+  "for music notation, including pitch, note, dynamic, score, etc. A Ruby-based "
+  "DSL is provided to aid in composition. Scores can be converted to common "
+  "formats, like MIDI and LilyPond. Scores can also be rendered as audio via "
+  "SuperCollider."
   spec.homepage      = "https://github.com/jamestunnell/musicality"
   spec.license       = "MIT"
 
@@ -24,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 2.9"
   spec.add_development_dependency "pry"
-  
+
   spec.add_dependency "treetop", "~> 1.5"
   spec.add_dependency 'midilib', '~> 2.0'
   spec.add_dependency 'docopt', '~> 0.5'

data/spec/composition/dsl/part_methods_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Part do
+  describe '#dynamic_change' do
+    before :each do
+      @part = Part.new(Dynamics::MP, notes: "/4 /4D4 /8C3 /16C3".to_notes)
+    end
+
+    context 'transition_dur is 0' do
+      context 'offset is 0' do
+        it 'should create an immediate dynamic change at the end of the part' do
+          @part.dynamic_change Dynamics::PP
+          expect(@part.dynamic_changes.size).to eq(1)
+          expect(@part.dynamic_changes).to have_key(@part.duration)
+          expect(@part.dynamic_changes.values.first).to eq Change::Immediate.new(Dynamics::PP)
+        end
+      end
+
+      context 'offset is not 0'
+    end
+
+    context 'transition_dur is not 0'
+  end
+end

data/spec/notation/conversion/score_conversion_spec.rb

@@ -23,7 +23,8 @@ describe Score::Tempo do
       1 => Change::Immediate.new(TWO_FOUR),
       3 => Change::Immediate.new(SIX_EIGHT)
     }
-    @score = Score::Tempo.new(THREE_FOUR, 120,
+    @score = Score::Tempo.new(120,
+      start_meter: THREE_FOUR,
       parts: @parts,
       program: @prog,
       tempo_changes: tcs,

data/spec/notation/conversion/score_converter_spec.rb

@@ -4,27 +4,27 @@ describe ScoreConverter do
   describe '#initialize' do
     context 'current score is invalid' do
       it 'should raise NotValidError' do
-        score = Score::Tempo.new(1, 120)
+        score = Score::Tempo.new(120, start_meter: 1)
         expect { ScoreConverter.new(score,200) }.to raise_error(NotValidError)
       end
-    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::Tempo.new(FOUR_FOUR, 120,
+      @score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
         parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => @changeA, 3 => @changeB })}
       )
     end
-    
+
     it 'should return Hash with original part names' do
       parts = ScoreConverter.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 note-based to time-based' do
       parts = ScoreConverter.new(@score,200).convert_parts
       parts.should have_key("simple")
@@ -35,7 +35,7 @@ describe ScoreConverter do
       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.new(@score,200).convert_parts
       parts.should have_key("simple")
@@ -48,10 +48,10 @@ describe ScoreConverter do
       change.end_value.should eq(@changeB.end_value)
       change.duration.should eq(4)
     end
-    
+
     context 'gradual changes with positive elapsed and/or remaining' do
      it 'should change elapsed and remaining so they reflect time-based offsets' do
-       score = Score::Tempo.new(THREE_FOUR,120, parts: {
+       score = Score::Tempo.new(120, start_meter: THREE_FOUR, parts: {
          "abc" => Part.new(Dynamics::P, dynamic_changes: {
              2 => Change::Gradual.linear(Dynamics::F,2).to_trimmed(1, 3),
              7 => Change::Gradual.linear(Dynamics::F,1).to_trimmed(4, 5)
@@ -60,27 +60,27 @@ describe ScoreConverter do
        converter = ScoreConverter.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,4).to_trimmed(2,6))
        dcs[14.0].should eq(Change::Gradual.linear(Dynamics::F,2).to_trimmed(8,10))
      end
     end
   end
-  
+
   describe '#convert_program' do
     before :each do
       @prog = [0...4,2...5]
-      @score = Score::Tempo.new(FOUR_FOUR, 120, program: @prog)
+      @score = Score::Tempo.new(120, start_meter: FOUR_FOUR, program: @prog)
       @converter = ScoreConverter.new(@score,200)
     end
-    
+
     it 'shuld return array with same size' do
       prog = @converter.convert_program
       prog.should be_a Array
       prog.size.should eq(@score.program.size)
     end
-  
+
     it 'should convert program segments offsets from note-based to time-based' do
       prog = ScoreConverter.new(@score,200).convert_program
       prog.size.should eq(2)
@@ -88,7 +88,7 @@ describe ScoreConverter do
       prog[0].last.should eq(8)
       prog[1].first.should eq(4)
       prog[1].last.should eq(10)
-      
+
       @score.start_meter = THREE_FOUR
       prog = ScoreConverter.new(@score,200).convert_program
       prog.size.should eq(2)
@@ -98,31 +98,31 @@ describe ScoreConverter do
       prog[1].last.should eq(10)
     end
   end
-  
-  describe '#convert_score' do    
+
+  describe '#convert_score' do
     it 'should return a timed score' do
-      score = Score::Tempo.new(FOUR_FOUR, 120)
+      score = Score::Tempo.new(120, start_meter: FOUR_FOUR)
       converter = ScoreConverter.new(score,200)
       converter.convert_score.should be_a Score::Timed
     end
-  
+
     it 'should use output from convert_program' do
       prog =[0...4,2...5]
-      score = Score::Tempo.new(FOUR_FOUR, 120, program: prog)
+      score = Score::Tempo.new(120, start_meter: FOUR_FOUR, program: prog)
       converter = ScoreConverter.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::Tempo.new(FOUR_FOUR, 120,
+      score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
         parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
       )
       converter = ScoreConverter.new(score,200)
       nscore = converter.convert_score
       nscore.parts.should eq(converter.convert_parts)
     end
-  end  
+  end
 end

data/spec/notation/model/score_spec.rb

@@ -38,24 +38,39 @@ describe Score do
       it 'should return false' do
         score = Score.new(program: [0..2,0..2])
         score.collated?.should be false
-      end      
+      end
     end
-    
+
     context 'has program with 0 segments' do
       it 'should return false' do
         score = Score.new(program: [])
-        score.collated?.should be false        
+        score.collated?.should be false
       end
     end
-    
+
     context 'has program with 1 segment' do
       context 'program segment starts at 0' do
-        it 'should return true' do
-          score = Score.new(program: [0..2])
-          score.collated?.should be true
+        context 'program segment ends at score duration' do
+          it 'should return true' do
+            score = Score.new(program: [0..2],
+              parts: { "dummy" => Part.new(Dynamics::MP, notes: [Note.whole]*2)}
+            )
+            score.collated?.should be true
+          end
+        end
+
+        context 'program segment does not end at score duration' do
+          it 'should return false' do
+            score = Score.new(program: [0..1],
+              parts: { "dummy" => Part.new(Dynamics::MP, notes: [Note.whole]*2) }
+            )
+            score.collated?.should be false
+            score.program = [0..3]
+            score.collated?.should be false
+          end
         end
       end
-      
+
       context 'program segment does not start at 0' do
         it 'should return false' do
           score = Score.new(program: [1..2])
@@ -64,20 +79,20 @@ 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
@@ -94,7 +109,8 @@ end
 
 describe Score::Tempo do
   before :all do
-    @basic_score = Score::Tempo.new(TWO_FOUR, 120,
+    @basic_score = Score::Tempo.new(120,
+      start_meter: TWO_FOUR,
       meter_changes: {
         2 => Change::Immediate.new(FOUR_FOUR),
         4 => Change::Immediate.new(SIX_EIGHT),
@@ -109,52 +125,55 @@ describe Score::Tempo do
 
   describe '#initialize' do
     it 'should use empty containers for parameters not given' do
-      s = Score::Tempo.new(FOUR_FOUR,120)
+      s = Score::Tempo.new(120)
       s.parts.should be_empty
       s.program.should be_empty
+      s.tempo_changes.should be_empty
+      s.meter_changes.should be_empty
     end
-    
+
     it 'should assign given parameters' do
-      m = FOUR_FOUR
-      s = Score::Tempo.new(m,120)
-      s.start_meter.should eq m
+      s = Score::Tempo.new(120)
       s.start_tempo.should eq 120
-      
+
+      m = FOUR_FOUR
       parts = { "piano (LH)" => Samples::SAMPLE_PART }
       program = [0...0.75, 0...0.75]
       mcs = { 1 => Change::Immediate.new(THREE_FOUR) }
       tcs = { 1 => Change::Immediate.new(100) }
-      
-      s = Score::Tempo.new(m,120,
+
+      s = Score::Tempo.new(120,
+        start_meter: m,
         parts: parts,
         program: program,
         meter_changes: mcs,
         tempo_changes: tcs
       )
+      s.start_meter.should eq m
       s.parts.should eq parts
       s.program.should eq program
       s.meter_changes.should eq mcs
       s.tempo_changes.should eq tcs
     end
   end
-  
+
   describe '#duration' do
     context 'with no parts' do
       it 'should return 0' do
-        Score::Tempo.new(TWO_FOUR, 120).duration.should eq(0)
+        Score::Tempo.new(120).duration.should eq(0)
       end
     end
     context 'with one part' do
       it 'should return the duration of the part, in notes' do
-        Score::Tempo.new(TWO_FOUR, 120, parts: {
+        Score::Tempo.new(120, parts: {
           "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes)
         }).duration.should eq(1.75)
       end
     end
-    
+
     context 'with two parts' do
       it 'should return the duration of the longest part, in notes' do
-        Score::Tempo.new(TWO_FOUR, 120, parts: {
+        Score::Tempo.new(120, parts: {
           "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes),
           "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
         }).duration.should eq(2)
@@ -164,13 +183,14 @@ describe Score::Tempo do
 
   describe '#valid?' do
     {
-      'valid start tempo' => [ FOUR_FOUR, 40 ],
-      'valid tempo changes' => [ FOUR_FOUR, 30,
+      'valid start tempo' => [ 40 ],
+      'valid tempo changes' => [ 30,
         :tempo_changes => { 1 => Change::Gradual.linear(40, 2), 2 => Change::Immediate.new(50) } ],
-      'valid meter changes' => [ FOUR_FOUR, 120,
+      'valid start meter' => [80, :start_meter => FOUR_FOUR ],
+      'valid meter changes' => [ 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 => [0..2,0..2] ]
+      'valid part' => [ 120, :parts => { "piano" => Samples::SAMPLE_PART }],
+      'valid program' => [ 120, :program => [0..2,0..2] ]
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
@@ -178,26 +198,26 @@ describe Score::Tempo do
         end
       end
     end
-    
+
     {
-      'start tempo object is negative' => [ FOUR_FOUR, -1],
-      'start tempo object is zero' => [ FOUR_FOUR, 0],
-      'invalid start meter' => [ Meter.new(-1,"1/4".to_r), 120],
-      'non-meter start meter' => [ 1, 120],
-      'invalid meter in change' => [ FOUR_FOUR, 120,
+      'start tempo object is negative' => [ -1],
+      'start tempo object is zero' => [ 0],
+      'invalid start meter' => [ 120, :start_meter => Meter.new(-1,"1/4".to_r) ],
+      'non-meter start meter' => [ 120, :start_meter => 1 ],
+      'invalid meter in change' => [ 120,
         :meter_changes => { 1 => Change::Immediate.new(Meter.new(-2,"1/4".to_r)) } ],
-      'non-meter values in meter changes' => [ FOUR_FOUR, 120,
+      'non-meter values in meter changes' => [ 120,
         :meter_changes => { 1 => Change::Immediate.new(5) } ],
-      'non-immediate meter change' => [ FOUR_FOUR, 120,
+      'non-immediate meter change' => [ 120,
         :meter_changes => { 1 => Change::Gradual.linear(TWO_FOUR,1) } ],
-      'invalid part' => [ FOUR_FOUR, 120, :parts => { "piano" => Part.new(-0.1) }],
-      'invalid program' => [ FOUR_FOUR, 120, :program => [2..0] ],
+      'invalid part' => [ 120, :parts => { "piano" => Part.new(-0.1) }],
+      'invalid program' => [ 120, :program => [2..0] ],
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do
           Score::Tempo.new(*args).should be_invalid
         end
-      end      
+      end
     end
   end
 
@@ -233,17 +253,17 @@ describe Score::Timed do
       s.parts.should be_empty
       s.program.should be_empty
     end
-    
+
     it 'should assign given parameters' do
       parts = { "piano (LH)" => Samples::SAMPLE_PART }
       program = [0...0.75, 0...0.75]
-      
+
       s = Score::Timed.new(parts: parts, program: program)
       s.parts.should eq parts
       s.program.should eq program
     end
   end
-  
+
   describe '#duration' do
     it 'should return the duration of the longest part' do
       Score::Timed.new(parts: {
@@ -264,7 +284,7 @@ describe Score::Timed do
         end
       end
     end
-    
+
     {
       'invalid part' => [ :parts => { "piano" => Part.new(-0.1) }],
       'invalid program' => [ :program => [2..0] ],
@@ -273,7 +293,7 @@ describe Score::Timed do
         it 'should return false' do
           Score::Timed.new(*args).should be_invalid
         end
-      end 
+      end
     end
   end
 

data/spec/performance/conversion/score_collator_spec.rb

@@ -9,11 +9,11 @@ describe ScoreCollator do
           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::Tempo.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
             parts: {1 => @part},
             program: ["1/4".to_r..."5/4".to_r])
           collator = ScoreCollator.new(score)
@@ -24,10 +24,10 @@ describe ScoreCollator do
           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::Tempo.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
             parts: {1 => @part},
             program: ["1/8".to_r..."5/4".to_r])
           collator = ScoreCollator.new(score)
@@ -41,11 +41,11 @@ describe ScoreCollator do
         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::Tempo.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
             parts: {1 => @part},
             program: [0.to_r..."3/4".to_r])
           collator = ScoreCollator.new(score)
@@ -54,10 +54,10 @@ describe ScoreCollator do
           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::Tempo.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
             parts: {1 => @part},
             program: [0.to_r...1.to_r])
           collator = ScoreCollator.new(score)
@@ -67,10 +67,10 @@ describe ScoreCollator do
           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::Tempo.new(FOUR_FOUR, 120,
+          score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
             parts: {1 => @part},
             program: [0.to_r..."6/4".to_r])
           collator = ScoreCollator.new(score)
@@ -82,10 +82,10 @@ describe ScoreCollator do
         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::Tempo.new(FOUR_FOUR, 120,
+        score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
           parts: { 1 => Part.new(Dynamics::FF, dynamic_changes: {
             2 => Change::Gradual.linear(Dynamics::PP,5).trim(1,0)
           }) },
@@ -96,7 +96,7 @@ describe ScoreCollator do
         dcs = parts[1].dynamic_changes
         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
@@ -104,9 +104,9 @@ describe ScoreCollator do
         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::Tempo.new(FOUR_FOUR, 120,
+        score = Score::Tempo.new(120, start_meter: FOUR_FOUR,
           parts: { 1 => Part.new(Dynamics::FF, dynamic_changes: {
             2 => Change::Gradual.linear(Dynamics::PP,5).trim(1,1)
           }) },
@@ -119,17 +119,17 @@ describe ScoreCollator do
         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::Tempo.new(
-        FOUR_FOUR,120,
+        120, start_meter: FOUR_FOUR,
         parts: { "lead" => Part.new(Dynamics::MP, notes: notes) },
         program: [0..1,0..1],
       )
       collator = ScoreCollator.new(score)
       parts = collator.collate_parts
-      
+
       notes = parts["lead"].notes
       expect(notes.size).to eq 2
       notes.each do |note|
@@ -138,17 +138,17 @@ describe ScoreCollator do
       end
     end
   end
-  
+
   describe '#collate_tempo_changes' do
     before :all do
       @change0 = Change::Immediate.new(120)
       @change1 = Change::Immediate.new(200)
       @change2 = Change::Gradual.linear(100,1)
     end
-    
+
     context 'tempo change starts at end of program segment' do
       it 'should not be included in the tempo changes' do
-        score = Score::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
+        score = Score::Tempo.new(120, start_meter: FOUR_FOUR, tempo_changes: {
           1 => @change1, 2 => @change2 }, program: [0...2])
         collator = ScoreCollator.new(score)
         st, tcs = collator.collate_tempo_changes
@@ -159,24 +159,24 @@ describe ScoreCollator do
 
     context 'tempo change starts and ends before segment' do
       before :all do
-        score = Score::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
+        score = Score::Tempo.new(120, start_meter: FOUR_FOUR, tempo_changes: {
           2 => @change2 }, program: [4..5])
         collator = ScoreCollator.new(score)
         @st, @tcs = collator.collate_tempo_changes
       end
-      
+
       it 'should not be included in the tempo changes' do
         expect(@tcs.size).to eq 0
       end
-      
+
       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::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
+        score = Score::Tempo.new(120, start_meter: FOUR_FOUR, tempo_changes: {
           1.5.to_r => @change2 }, program: [2..4])
         collator = ScoreCollator.new(score)
         st, tcs = collator.collate_tempo_changes
@@ -186,10 +186,10 @@ describe ScoreCollator do
         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::Tempo.new(FOUR_FOUR, 120, tempo_changes: {
+        score = Score::Tempo.new(120, start_meter: FOUR_FOUR, tempo_changes: {
           1 => @change1, 2 => @change2 }, program: [0..2.5])
         collator = ScoreCollator.new(score)
         st, tcs = collator.collate_tempo_changes
@@ -207,7 +207,7 @@ describe ScoreCollator do
       change0 = Change::Immediate.new(FOUR_FOUR)
       change1 = Change::Immediate.new(THREE_FOUR)
       change2 = Change::Immediate.new(SIX_EIGHT)
-      score = Score::Tempo.new(FOUR_FOUR, 120, meter_changes: {
+      score = Score::Tempo.new(120, start_meter: FOUR_FOUR, meter_changes: {
         1 => change1, 2 => change2 }, program: [0...2])
       collator = ScoreCollator.new(score)
       sm, mcs = collator.collate_meter_changes