musicality 0.8.0 → 0.9.0

data/lib/musicality/version.rb

@@ -1,3 +1,3 @@
 module Musicality
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/musicality.gemspec

@@ -28,4 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "treetop", "~> 1.5"
   spec.add_dependency 'midilib', '~> 2.0'
   spec.add_dependency 'docopt', '~> 0.5'
+  spec.add_dependency 'ruby-osc', '~> 0.4'
+
+  spec.required_ruby_version = '>= 2.0'
 end

data/spec/composition/util/random_sampler_spec.rb

@@ -28,7 +28,7 @@ describe RandomSampler do
           sampler.values.each_with_index do |val,i|
             count = counts[val]
             tgt_prob = sampler.probabilities[i]
-            (count / 1000.to_f).should be_within(0.05).of(tgt_prob)
+            (count / 1000.to_f).should be_within(0.1).of(tgt_prob)
           end
         end
       end

data/spec/notation/conversion/measure_note_map_spec.rb

@@ -35,7 +35,7 @@ describe 'Conversion.measure_note_map' do
       @first_mc_off = 3
       @start_meter = THREE_FOUR
       @new_meter = TWO_FOUR
-      @score = Score::Measured.new(@start_meter, 120,
+      @score = Score::Tempo.new(@start_meter, 120,
         meter_changes: { @first_mc_off => Change::Immediate.new(@new_meter) },
         tempo_changes: {
           "1/2".to_r => Change::Gradual.linear(100,1),

data/spec/notation/conversion/note_time_converter_spec.rb

@@ -1,92 +1,12 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe NoteTimeConverter::Unmeasured do
-  describe '#notes_per_second_at' do
-    it 'should convert tempo using Tempo::QNPM.to_nps' do
-      tc = ValueComputer.new(
-        120, 1 => Change::Gradual.linear(100,1), 2 => Change::Gradual.linear(150,1))
-      converter = NoteTimeConverter::Unmeasured.new(tc,200)
-      (0..2).step(0.2).each do |offset|
-        nps = Tempo::QNPM.to_nps(tc.at(offset))
-        converter.notes_per_second_at(offset).should eq(nps)
-      end
-    end
-  end
-  
-  describe "#time_elapsed" do
-    context "constant tempo" do
-      before :each do
-        @tempo_computer = ValueComputer.new 120
-        sample_rate = 48
-        @converter = NoteTimeConverter::Unmeasured.new(@tempo_computer, sample_rate)
-      end
-  
-      it "should return a time of zero when note end is zero." do
-        @converter.time_elapsed(0, 0).should eq(0)
-      end
-      
-      it "should return a time of 1 second when note end is equal to the initial notes-per-second" do
-        note_end = @converter.notes_per_second_at(0)
-        @converter.time_elapsed(0, note_end).should eq(1)
-      end
-    end
-    
-    context "linear tempo-change" do
-      before :each do
-        @tempo_computer = ValueComputer.new(
-          120, 1 => Change::Gradual.linear(60, 1))
-        sample_rate = 200
-        @converter = NoteTimeConverter::Unmeasured.new(@tempo_computer, sample_rate)
-      end
-  
-      it "should return a time of zero when note end is zero." do
-        @converter.time_elapsed(0.0, 0.0).should eq(0.0)
-      end
-  
-      it "should return a time of 3 sec during a 1-note long transition from 120bpm to 60bpm" do
-        @converter.notes_per_second_at(1.0).should eq(0.5)
-        @converter.notes_per_second_at(2.0).should eq(0.25)
-  
-        @converter.time_elapsed(1.0, 2.0).should be_within(0.05).of(2.77)
-      end
-  
-    end
-  end
-  
-  describe "#note_time_map" do
-    context "constant tempo" do
-      before :each do 
-        @tempo_computer = ValueComputer.new 120
-        sample_rate = 4800
-        @converter = NoteTimeConverter::Unmeasured.new(
-          @tempo_computer, sample_rate)
-      end
-  
-      it "should map offset 0.0 to time 0.0" do
-        map = @converter.note_time_map [0.0]
-        map[0.0].should eq(0.0)
-      end
-
-      it "should map offset 0.25 to time 0.5" do
-        map = @converter.note_time_map [0.0, 0.25]
-        map[0.25].should be_within(0.01).of(0.5)
-      end
-      
-      it "should map offset 1.0 to time 2.0" do
-        map = @converter.note_time_map [0.0, 1.0]
-        map[1.0].should be_within(0.01).of(2.0)
-      end
-    end
-  end
-end
-
-describe NoteTimeConverter::Measured do
+describe NoteTimeConverter::Tempo do
   describe '#notes_per_second_at' do
     it 'should convert tempo using Tempo::BPM.to_nps' do
       tc = ValueComputer.new(120, 1 => Change::Gradual.linear(100,1),
                              2 => Change::Gradual.linear(150,1))
       bdc = ValueComputer.new(0.25.to_r, 2.5 => Change::Immediate.new(0.375.to_r))
-      converter = NoteTimeConverter::Measured.new(tc,bdc,200)
+      converter = NoteTimeConverter.new(tc,bdc,200)
       (0..3.2).step(0.2).each do |offset|
         nps = Tempo::BPM.to_nps(tc.at(offset), bdc.at(offset))
         converter.notes_per_second_at(offset).should eq(nps)
@@ -100,7 +20,7 @@ describe NoteTimeConverter::Measured do
         @tempo_computer = ValueComputer.new 120
         @bdur_computer = ValueComputer.new Rational(1,4)
         sample_rate = 48
-        @converter = NoteTimeConverter::Measured.new(@tempo_computer, @bdur_computer, sample_rate)
+        @converter = NoteTimeConverter.new(@tempo_computer, @bdur_computer, sample_rate)
       end
   
       it "should return a time of zero when note end is zero." do
@@ -118,7 +38,7 @@ describe NoteTimeConverter::Measured do
         @tempo_computer = ValueComputer.new(120, 1 => Change::Gradual.linear(60, 1))
         @bdur_computer = ValueComputer.new Rational(1,4)
         sample_rate = 200
-        @converter = NoteTimeConverter::Measured.new(@tempo_computer, @bdur_computer, sample_rate)
+        @converter = NoteTimeConverter.new(@tempo_computer, @bdur_computer, sample_rate)
       end
   
       it "should return a time of zero when note end is zero." do
@@ -141,7 +61,7 @@ describe NoteTimeConverter::Measured do
         @tempo_computer = ValueComputer.new 120
         @bdur_computer = ValueComputer.new Rational(1,4)
         sample_rate = 4800
-        @converter = NoteTimeConverter::Measured.new(@tempo_computer, @bdur_computer, sample_rate)
+        @converter = NoteTimeConverter.new(@tempo_computer, @bdur_computer, sample_rate)
       end
   
       it "should map offset 0.0 to time 0.0" do

data/spec/notation/conversion/score_conversion_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Score::Measured do
+describe Score::Tempo do
   before :all do
     @parts = {
       "piano" => Part.new(Dynamics::MP,
@@ -23,7 +23,7 @@ describe Score::Measured do
       1 => Change::Immediate.new(TWO_FOUR),
       3 => Change::Immediate.new(SIX_EIGHT)
     }
-    @score = Score::Measured.new(THREE_FOUR, 120,
+    @score = Score::Tempo.new(THREE_FOUR, 120,
       parts: @parts,
       program: @prog,
       tempo_changes: tcs,
@@ -94,7 +94,7 @@ describe Score::Measured do
     context 'meter change at offset 0' do
       before :all do
         @change = Change::Immediate.new(THREE_FOUR)
-        @score2 = Score::Measured.new(FOUR_FOUR, 120, meter_changes: { 0 => @change })
+        @score2 = Score::Tempo.new(FOUR_FOUR, 120, meter_changes: { 0 => @change })
         @mdurs2 = @score2.measure_durations
       end
   
@@ -113,7 +113,7 @@ describe Score::Measured do
     
     context 'no meter changes' do
       before :all do
-        @score3 = Score::Measured.new(FOUR_FOUR, 120)
+        @score3 = Score::Tempo.new(FOUR_FOUR, 120)
         @mdurs3 = @score3.measure_durations
       end
   
@@ -132,45 +132,10 @@ describe Score::Measured do
   end
   
   describe '#to_timed' do
-    it 'should use ScoreConverter::Measured#convert_score' do
+    it 'should use ScoreConverter#convert_score' do
       nscore1 = @score.to_timed(200)
-      nscore2 = ScoreConverter::Measured.new(@score,200).convert_score
+      nscore2 = ScoreConverter.new(@score,200).convert_score
       nscore1.should eq(nscore2)
     end
   end
 end
-
-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.linear(Dynamics::MF,2),
-          14 => Change::Immediate.new(Dynamics::PP),
-        }
-      )
-    }
-    @prog = [0...3,4...7,1...20,17..."45/2".to_r]
-    tcs = {
-      0 => Change::Immediate.new(120),
-      4 => Change::Gradual.linear(60,2),
-      11 => Change::Immediate.new(110)
-    }
-    @score = Score::Unmeasured.new(120,
-      parts: @parts,
-      program: @prog,
-      tempo_changes: tcs,
-    )
-  end
-  
-  describe '#to_timed' do
-    it 'should use ScoreConverter::Unmeasured#convert_score' do
-      nscore1 = @score.to_timed(200)
-      nscore2 = ScoreConverter::Unmeasured.new(@score,200).convert_score
-      nscore1.should eq(nscore2)
-    end
-  end
-end

data/spec/notation/conversion/score_converter_spec.rb

@@ -1,15 +1,11 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe ScoreConverter::TempoBased do
-  
-end
-
-describe ScoreConverter::Measured do
+describe ScoreConverter 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)
+        score = Score::Tempo.new(1, 120)
+        expect { ScoreConverter.new(score,200) }.to raise_error(NotValidError)
       end
     end    
   end
@@ -18,19 +14,19 @@ describe ScoreConverter::Measured do
     before :each do
       @changeA = Change::Immediate.new(Dynamics::PP)
       @changeB = Change::Gradual.linear(Dynamics::F, 2)
-      @score = Score::Measured.new(FOUR_FOUR, 120,
+      @score = Score::Tempo.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 = 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 measure-based to note-based' do
-      parts = ScoreConverter::Measured.new(@score,200).convert_parts
+      parts = ScoreConverter.new(@score,200).convert_parts
       parts.should have_key("simple")
       part = parts["simple"]
       part.dynamic_changes.keys.sort.should eq([2,6])
@@ -41,7 +37,7 @@ describe ScoreConverter::Measured do
       change.duration.should eq(4)
       
       #@score.start_meter = THREE_FOUR
-      #parts = ScoreConverter::Measured.new(@score,200).convert_parts
+      #parts = ScoreConverter.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)])
@@ -55,13 +51,13 @@ describe ScoreConverter::Measured do
     
     #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: {
+    #    score = Score::Tempo.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)
+    #    converter = ScoreConverter.new(score)
     #    parts = converter.convert_parts
     #    dcs = parts["abc"].dynamic_changes
     #    
@@ -75,8 +71,8 @@ describe ScoreConverter::Measured do
   describe '#convert_program' do
     before :each do
       @prog = [0...4,2...5]
-      @score = Score::Measured.new(FOUR_FOUR, 120, program: @prog)
-      @converter = ScoreConverter::Measured.new(@score,200)
+      @score = Score::Tempo.new(FOUR_FOUR, 120, program: @prog)
+      @converter = ScoreConverter.new(@score,200)
     end
     
     it 'shuld return array with same size' do
@@ -86,7 +82,7 @@ describe ScoreConverter::Measured do
     end
   
     it 'should convert program segments offsets from measure-based to note-based' do
-      prog = ScoreConverter::Measured.new(@score,200).convert_program
+      prog = ScoreConverter.new(@score,200).convert_program
       prog.size.should eq(2)
       prog[0].first.should eq(0)
       prog[0].last.should eq(8)
@@ -94,7 +90,7 @@ describe ScoreConverter::Measured do
       prog[1].last.should eq(10)
       
       @score.start_meter = THREE_FOUR
-      prog = ScoreConverter::Measured.new(@score,200).convert_program
+      prog = ScoreConverter.new(@score,200).convert_program
       prog.size.should eq(2)
       prog[0].first.should eq(0)
       prog[0].last.should eq(6)
@@ -105,15 +101,15 @@ describe ScoreConverter::Measured do
   
   describe '#convert_score' do    
     it 'should return a timed score' do
-      score = Score::Measured.new(FOUR_FOUR, 120)
-      converter = ScoreConverter::Measured.new(score,200)
+      score = Score::Tempo.new(FOUR_FOUR, 120)
+      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::Measured.new(FOUR_FOUR, 120, program: prog)
-      converter = ScoreConverter::Measured.new(score,200)
+      score = Score::Tempo.new(FOUR_FOUR, 120, program: prog)
+      converter = ScoreConverter.new(score,200)
       nscore = converter.convert_score
       nscore.program.should eq(converter.convert_program)
     end
@@ -121,126 +117,12 @@ describe ScoreConverter::Measured do
     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,
+      score = Score::Tempo.new(FOUR_FOUR, 120,
         parts: {"simple" => Part.new(Dynamics::MP, dynamic_changes: { 1 => changeA, 3 => changeB })}
       )
-      converter = ScoreConverter::Measured.new(score,200)
+      converter = ScoreConverter.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 = [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 array with same size' do
-      @prog2.should be_a Array
-      @prog2.size.should eq(@prog.size)
-    end
-  
-    it 'should convert program segments offsets from note-based to time-based' do
-      prog = @prog2
-      prog[0].first.should eq(0)
-      prog[0].last.should eq(8)
-      prog[1].first.should eq(4)
-      prog[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 = [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