musicality 0.11.1 → 0.12.0

data/spec/notation/conversion/change_conversion_spec.rb

@@ -4,39 +4,39 @@ describe Change::Immediate do
   describe '#offsets' do
     it 'should return array with just the given base offset' do
       c = Change::Immediate.new(12)
-      c.offsets(44).should eq([44])
+      expect(c.offsets(44)).to eq([44])
     end
   end
-  
+
   describe '#remap' do
     it 'should return a clone of the change' do
       c = Change::Immediate.new(12)
       c2 = c.remap(1,{})
-      c2.should eq(c)
-      c2.should_not be c
+      expect(c2).to eq(c)
+      expect(c2).to_not be c
     end
   end
-  
+
   describe '#to_transition' do
     before :all do
       @ch = Change::Immediate.new(20)
       @off = 0
       @f = @ch.to_transition(@off,0)
     end
-    
+
     it 'should return a peicewise function' do
-      @f.should be_a Function::Piecewise
+      expect(@f).to be_a Function::Piecewise
     end
-    
+
     it 'should return a function defined from base offset to DOMAIN_MAX' do
-      @f.domain_include?(@off).should be true
-      @f.domain_include?(Function::DOMAIN_MAX).should be true
+      expect(@f.domain_include?(@off)).to be true
+      expect(@f.domain_include?(Function::DOMAIN_MAX)).to be true
     end
-    
+
     it 'should return change value from base offset onward' do
-      @f.at(@off).should eq(@ch.end_value)
-      @f.at(@off+1).should eq(@ch.end_value)
-      @f.at(@off+1000).should eq(@ch.end_value)
+      expect(@f.at(@off)).to eq(@ch.end_value)
+      expect(@f.at(@off+1)).to eq(@ch.end_value)
+      expect(@f.at(@off+1000)).to eq(@ch.end_value)
     end
   end
 end
@@ -46,41 +46,41 @@ describe Change::Gradual do
     @change = Change::Gradual.linear(100,1.5)
     @base = 25.5
   end
-  
+
   describe '#offsets' do
     before :all do
       @offsets = @change.offsets(@base)
     end
-    
+
     it 'should return array with 2 elements' do
-      @offsets.size.should eq(2)
+      expect(@offsets.size).to eq(2)
     end
-    
+
     it 'should include the given base offset' do
-      @offsets.should include(@base)
+      expect(@offsets).to include(@base)
     end
-    
+
     it 'should include the base offset + duration' do
-      @offsets.should include(@base + @change.duration)
+      expect(@offsets).to include(@base + @change.duration)
     end
   end
-  
+
   describe '#remap' do
     before :all do
       @c2 = @change.remap(@base, @base => 3, (@base + @change.duration) => 5)
     end
-    
+
     it 'should return a new Gradual' do
-      @c2.should be_a(Change::Gradual)
-      @c2.should_not be(@change)
+      expect(@c2).to be_a(Change::Gradual)
+      expect(@c2).to_not be(@change)
     end
-    
+
     it 'should keep end value, and change duration based on given offset map' do
-      @c2.end_value.should eq(@change.end_value)
-      @c2.duration.should eq(2)
+      expect(@c2.end_value).to eq(@change.end_value)
+      expect(@c2.duration).to eq(2)
     end
   end
-  
+
   describe '#to_transition' do
     { 'linear transition' => Change::Gradual.linear(130,20),
       'sigmoid transition' => Change::Gradual.sigmoid(130,20)
@@ -91,43 +91,43 @@ describe Change::Gradual do
           @start_value = 50
           @func = @change.to_transition(@offset, @start_value)
         end
-        
+
         it 'should return a piecewise function' do
-          @func.should be_a Function::Piecewise
+          expect(@func).to be_a Function::Piecewise
         end
-        
+
         it 'should return a function that is undefined before base offset' do
-          @func.domain_include?(@offset-1e-5).should be false
-          @func.domain_include?(@offset-1e5).should be false
+          expect(@func.domain_include?(@offset-1e-5)).to be false
+          expect(@func.domain_include?(@offset-1e5)).to be false
         end
-        
+
         it 'should return a function defined from base offset to DOMAIN_MAX' do
-          @func.domain_include?(@offset).should be true
-          @func.domain_include?(@offset + @change.duration/2.0).should be true
-          @func.domain_include?(@offset + @change.duration).should be true
-          @func.domain_include?(@offset + @change.duration + 1).should be true
-          @func.domain_include?(Function::DOMAIN_MAX).should be true
+          expect(@func.domain_include?(@offset)).to be true
+          expect(@func.domain_include?(@offset + @change.duration/2.0)).to be true
+          expect(@func.domain_include?(@offset + @change.duration)).to be true
+          expect(@func.domain_include?(@offset + @change.duration + 1)).to be true
+          expect(@func.domain_include?(Function::DOMAIN_MAX)).to be true
         end
-  
+
         it 'should make function that evaluates to start_value at start offset' do
-          @func.at(@offset).should eq(@start_value)
+          expect(@func.at(@offset)).to eq(@start_value)
         end
-  
+
         it 'should make function that evaluates to end_value at start offset + duration' do
-          @func.at(@offset + @change.duration).should eq(@change.end_value)
+          expect(@func.at(@offset + @change.duration)).to eq(@change.end_value)
         end
-        
+
         it 'should make function that evaluates to 1/2 between start/end value at 1/2 between start/end offset' do
           tgt = (@change.end_value + @start_value) / 2.0
-          @func.at(@offset + @change.duration/2.0).should be_within(1e-5).of(tgt)
+          expect(@func.at(@offset + @change.duration/2.0)).to be_within(1e-5).of(tgt)
         end
-        
+
         it 'should make function that evaluates to end value after change has elapsed' do
-          @func.at(@offset + @change.duration + 1).should eq(@change.end_value)
+          expect(@func.at(@offset + @change.duration + 1)).to eq(@change.end_value)
         end
       end
     end
-      
+
     context 'start value already defined in change' do
       { 'linear transition' => Change::Gradual.linear(130,20,start_value:80),
         'sigmoid transition' => Change::Gradual.sigmoid(130,20,start_value:80)
@@ -137,7 +137,7 @@ describe Change::Gradual do
             offset = 3
             start_value = 50
             func = change.to_transition(offset, start_value)
-            func.at(offset).should eq(change.start_value)
+            expect(func.at(offset)).to eq(change.start_value)
           end
         end
       end
@@ -150,53 +150,53 @@ describe Change::Gradual::Trimmed do
     @change = Change::Gradual.linear(100,1.5.to_r).to_trimmed(0.5.to_r,0.5.to_r)
     @base = 25.5.to_r
   end
-  
+
   describe '#offsets' do
     before :all do
       @offsets = @change.offsets(@base)
     end
-    
+
     it 'should return array with 2 elements' do
-      @offsets.size.should eq(4)
+      expect(@offsets.size).to eq(4)
     end
-    
+
     it 'should include the given base offset' do
-      @offsets.should include(@base)
+      expect(@offsets).to include(@base)
     end
-    
+
     it 'should include the base offset - preceding' do
-      @offsets.should include(@base - @change.preceding)
+      expect(@offsets).to include(@base - @change.preceding)
     end
-    
+
     it 'should include the base offset + remaining' do
-      @offsets.should include(@base + @change.remaining)
+      expect(@offsets).to include(@base + @change.remaining)
     end
-    
+
     it 'should include the base offset - preceding + duration' do
-      @offsets.should include(@base - @change.preceding + @change.duration)
+      expect(@offsets).to include(@base - @change.preceding + @change.duration)
     end
   end
-  
+
   describe '#remap' do
     before :all do
       @offsets = { @base => 3, (@base - @change.preceding) => 0,
         (@base + @change.remaining) => 5, (@base - @change.preceding + @change.duration) => 7 }
       @c2 = @change.remap(@base, @offsets)
     end
-    
+
     it 'should return a new Gradual::Trimmed' do
-      @c2.should be_a(Change::Gradual::Trimmed)
-      @c2.should_not be(@change)
+      expect(@c2).to be_a(Change::Gradual::Trimmed)
+      expect(@c2).to_not be(@change)
     end
-    
+
     it 'should keep end value, and change duration based on given offset map' do
-      @c2.end_value.should eq(@change.end_value)
-      @c2.duration.should eq(7)
-      @c2.preceding.should eq(3)
-      @c2.remaining.should eq(2)
+      expect(@c2.end_value).to eq(@change.end_value)
+      expect(@c2.duration).to eq(7)
+      expect(@c2.preceding).to eq(3)
+      expect(@c2.remaining).to eq(2)
     end
   end
-  
+
   describe '#to_transition' do
     Change::Gradual::TRANSITIONS.each do |transition|
       context "#{transition} transition" do
@@ -207,38 +207,38 @@ describe Change::Gradual::Trimmed do
               untrimmed_offset = 0
               untrimmed_start_val = 50
               @untrimmed_trans = untrimmed.to_transition(untrimmed_offset, untrimmed_start_val)
-              
+
               trimmed = untrimmed.trim(5,3)
               trimmed_offset = untrimmed_offset + trimmed.preceding
               trimmed_start_val = @untrimmed_trans.at(trimmed_offset)
               @trimmed_trans = trimmed.to_transition(trimmed_offset, trimmed_start_val)
-              
+
               @xrange = trimmed_offset..(trimmed_offset + trimmed.remaining)
             end
-            
+
             it 'should produce function that is undefined before trimmed domain' do
-              @trimmed_trans.domain_include?(@xrange.first-1).should be false
+              expect(@trimmed_trans.domain_include?(@xrange.first-1)).to be false
             end
-    
+
             it 'should produce function that is defined for trimmed domain' do
-              @trimmed_trans.domain_include?(@xrange.first).should be true
-              @trimmed_trans.domain_include?((@xrange.first + @xrange.last)/2.0).should be true
-              @trimmed_trans.domain_include?(@xrange.last).should be true
+              expect(@trimmed_trans.domain_include?(@xrange.first)).to be true
+              expect(@trimmed_trans.domain_include?((@xrange.first + @xrange.last)/2.0)).to be true
+              expect(@trimmed_trans.domain_include?(@xrange.last)).to be true
             end
-            
+
             it 'should produce function that is defined after trimmed domain' do
-              @trimmed_trans.domain_include?(@xrange.last+1).should be true
-              @trimmed_trans.domain_include?(Function::DOMAIN_MAX).should be true
+              expect(@trimmed_trans.domain_include?(@xrange.last+1)).to be true
+              expect(@trimmed_trans.domain_include?(Function::DOMAIN_MAX)).to be true
             end
-            
+
             it 'should produce function that stays at end value after transition' do
-              @trimmed_trans.at(@xrange.last + 1).should eq(@trimmed_trans.at(@xrange.last))
+              expect(@trimmed_trans.at(@xrange.last + 1)).to eq(@trimmed_trans.at(@xrange.last))
             end
-            
+
             it 'should produce function that samples same as equivalent untrimmed' do
               srate = 50
-              @trimmed_trans.sample(@xrange, srate).should eq(@untrimmed_trans.sample(@xrange, srate))
-            end            
+              expect(@trimmed_trans.sample(@xrange, srate)).to eq(@untrimmed_trans.sample(@xrange, srate))
+            end
           end
         end
       end

data/spec/notation/conversion/note_time_converter_spec.rb

@@ -9,11 +9,11 @@ describe NoteTimeConverter::Tempo do
       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)
+        expect(converter.notes_per_second_at(offset)).to eq(nps)
       end
     end
   end
-  
+
   describe "#time_elapsed" do
     context "constant tempo, beat duration" do
       before :each do
@@ -22,17 +22,17 @@ describe NoteTimeConverter::Tempo do
         sample_rate = 48
         @converter = NoteTimeConverter.new(@tempo_computer, @bdur_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)
+        expect(@converter.time_elapsed(0, 0)).to 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)
+        expect(@converter.time_elapsed(0, note_end)).to eq(1)
       end
     end
-    
+
     context "linear tempo-change, constant beat duration" do
       before :each do
         @tempo_computer = ValueComputer.new(120, 1 => Change::Gradual.linear(60, 1))
@@ -40,43 +40,43 @@ describe NoteTimeConverter::Tempo do
         sample_rate = 200
         @converter = NoteTimeConverter.new(@tempo_computer, @bdur_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)
+        expect(@converter.time_elapsed(0.0, 0.0)).to 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)
+        expect(@converter.notes_per_second_at(1.0)).to eq(0.5)
+        expect(@converter.notes_per_second_at(2.0)).to eq(0.25)
+
+        expect(@converter.time_elapsed(1.0, 2.0)).to be_within(0.05).of(2.77)
       end
-  
+
     end
   end
-  
+
   describe "#note_time_map" do
     context "constant tempo, beat duration" do
-      before :each do 
+      before :each do
         @tempo_computer = ValueComputer.new 120
         @bdur_computer = ValueComputer.new Rational(1,4)
         sample_rate = 4800
         @converter = NoteTimeConverter.new(@tempo_computer, @bdur_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)
+        expect(map[0.0]).to 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)
+        expect(map[0.25]).to 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)
+        expect(map[1.0]).to be_within(0.01).of(2.0)
       end
     end
   end

data/spec/notation/conversion/score_conversion_spec.rb

@@ -36,7 +36,7 @@ describe Score::Tempo do
     it 'should use ScoreConverter#convert_score' do
       nscore1 = @score.to_timed(200)
       nscore2 = ScoreConverter.new(@score,200).convert_score
-      nscore1.should eq(nscore2)
+      expect(nscore1).to eq(nscore2)
     end
   end
 end

data/spec/notation/conversion/score_converter_spec.rb

@@ -21,32 +21,32 @@ describe ScoreConverter do
 
     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)
+      expect(parts).to be_a Hash
+      expect(parts.keys.sort).to 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")
+      expect(parts).to have_key("simple")
       part = parts["simple"]
-      part.dynamic_changes.keys.sort.should eq([2,6])
+      expect(part.dynamic_changes.keys.sort).to eq([2,6])
       change = part.dynamic_changes[2.0]
-      change.end_value.should eq(@changeA.end_value)
+      expect(change.end_value).to eq(@changeA.end_value)
       change = part.dynamic_changes[6.0]
-      change.end_value.should eq(@changeB.end_value)
-      change.duration.should eq(4)
+      expect(change.end_value).to eq(@changeB.end_value)
+      expect(change.duration).to eq(4)
 
       @score.start_meter = THREE_FOUR
       parts = ScoreConverter.new(@score,200).convert_parts
-      parts.should have_key("simple")
+      expect(parts).to have_key("simple")
       part = parts["simple"]
-      part.dynamic_changes.keys.sort.should eq([2,6])
+      expect(part.dynamic_changes.keys.sort).to eq([2,6])
       change = part.dynamic_changes[2.0]
-      change.end_value.should eq(@changeA.end_value)
-      change.duration.should eq(0)
+      expect(change.end_value).to eq(@changeA.end_value)
+      expect(change.duration).to eq(0)
       change = part.dynamic_changes[6.0]
-      change.end_value.should eq(@changeB.end_value)
-      change.duration.should eq(4)
+      expect(change.end_value).to eq(@changeB.end_value)
+      expect(change.duration).to eq(4)
     end
 
     context 'gradual changes with positive elapsed and/or remaining' do
@@ -61,9 +61,9 @@ describe ScoreConverter do
        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))
+       expect(dcs.keys).to eq([4, 14])
+       expect(dcs[4.0]).to eq(Change::Gradual.linear(Dynamics::F,4).to_trimmed(2,6))
+       expect(dcs[14.0]).to eq(Change::Gradual.linear(Dynamics::F,2).to_trimmed(8,10))
      end
     end
   end
@@ -77,25 +77,25 @@ describe ScoreConverter do
 
     it 'shuld return array with same size' do
       prog = @converter.convert_program
-      prog.should be_a Array
-      prog.size.should eq(@score.program.size)
+      expect(prog).to be_a Array
+      expect(prog.size).to 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)
-      prog[0].first.should eq(0)
-      prog[0].last.should eq(8)
-      prog[1].first.should eq(4)
-      prog[1].last.should eq(10)
+      expect(prog.size).to eq(2)
+      expect(prog[0].first).to eq(0)
+      expect(prog[0].last).to eq(8)
+      expect(prog[1].first).to eq(4)
+      expect(prog[1].last).to eq(10)
 
       @score.start_meter = THREE_FOUR
       prog = ScoreConverter.new(@score,200).convert_program
-      prog.size.should eq(2)
-      prog[0].first.should eq(0)
-      prog[0].last.should eq(8)
-      prog[1].first.should eq(4)
-      prog[1].last.should eq(10)
+      expect(prog.size).to eq(2)
+      expect(prog[0].first).to eq(0)
+      expect(prog[0].last).to eq(8)
+      expect(prog[1].first).to eq(4)
+      expect(prog[1].last).to eq(10)
     end
   end
 
@@ -103,7 +103,7 @@ describe ScoreConverter do
     it 'should return a timed score' do
       score = Score::Tempo.new(120, start_meter: FOUR_FOUR)
       converter = ScoreConverter.new(score,200)
-      converter.convert_score.should be_a Score::Timed
+      expect(converter.convert_score).to be_a Score::Timed
     end
 
     it 'should use output from convert_program' do
@@ -111,7 +111,7 @@ describe ScoreConverter do
       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)
+      expect(nscore.program).to eq(converter.convert_program)
     end
 
     it 'should use output from convert_parts' do
@@ -122,7 +122,7 @@ describe ScoreConverter do
       )
       converter = ScoreConverter.new(score,200)
       nscore = converter.convert_score
-      nscore.parts.should eq(converter.convert_parts)
+      expect(nscore.parts).to eq(converter.convert_parts)
     end
   end
 end

data/spec/notation/conversion/tempo_conversion_spec.rb

@@ -4,17 +4,17 @@ describe Tempo::QNPM do
   before :all do
     @tempo = 60
   end
-  
+
   describe '#to_nps' do
     it 'should change tempo value to be 1/240th' do
-      Tempo::QNPM.to_nps(@tempo).should eq(Rational(1,4))
+      expect(Tempo::QNPM.to_nps(@tempo)).to eq(Rational(1,4))
     end
   end
-  
+
   describe '#to_bpm' do
     it 'should divide tempo value by (4*beatdur)' do
-      Tempo::QNPM.to_bpm(@tempo, Rational(1,4)).should eq(60)
-      Tempo::QNPM.to_bpm(@tempo, Rational(1,2)).should eq(30)
+      expect(Tempo::QNPM.to_bpm(@tempo, Rational(1,4))).to eq(60)
+      expect(Tempo::QNPM.to_bpm(@tempo, Rational(1,2))).to eq(30)
     end
   end
 end
@@ -23,18 +23,18 @@ describe Tempo::BPM do
   before :all do
     @tempo = 60
   end
-  
+
   describe '#to_nps' do
     it 'should multiply tempo value by beatdur/60' do
-      Tempo::BPM.to_nps(@tempo,Rational(1,4)).should eq(Rational(1,4))
+      expect(Tempo::BPM.to_nps(@tempo,Rational(1,4))).to eq(Rational(1,4))
     end
   end
-  
+
   describe '#to_qnpm' do
     it 'should multiply tempo value by (4*beatdur)' do
-      Tempo::BPM.to_qnpm(@tempo,Rational(1,8)).should eq(30)
-      Tempo::BPM.to_qnpm(@tempo,Rational(1,4)).should eq(60)
-      Tempo::BPM.to_qnpm(@tempo,Rational(1,2)).should eq(120)
+      expect(Tempo::BPM.to_qnpm(@tempo,Rational(1,8))).to eq(30)
+      expect(Tempo::BPM.to_qnpm(@tempo,Rational(1,4))).to eq(60)
+      expect(Tempo::BPM.to_qnpm(@tempo,Rational(1,2))).to eq(120)
     end
   end
 end