musicality 0.11.1 → 0.12.0

data/spec/notation/parsing/pitch_parsing_spec.rb

@@ -4,11 +4,11 @@ describe Parsing::PitchParser do
   before :all do
     @parser = Parsing::PitchParser.new
   end
-  
+
   ["C4","C#9","Ab0","G#2","E2+22","Cb5-99","G200","Bb9951+3920"
   ].each do |str|
     it "should parse #{str}" do
-      @parser.should parse(str)
+      expect(@parser).to parse(str)
     end
   end
 end

data/spec/notation/parsing/segment_parsing_spec.rb

@@ -16,11 +16,11 @@ describe Parsing::SegmentParser do
       str,tgt = str_tgt
       res = parser.parse(str)
       it 'should parse' do
-        res.should_not be nil
+        expect(res).to_not be nil
       end
-      
+
       it 'should return node that converts to exclusive range via #to_range' do
-        res.to_range.should eq tgt
+        expect(res.to_range).to eq tgt
       end
     end
   end

data/spec/notation/util/function_spec.rb

@@ -3,33 +3,33 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe Function::Constant do
   it 'should always return the same value' do
     f = Function::Constant.new(20)
-    f.at(0).should eq(20)
-    f.at(-1000).should eq(20)
-    f.at(1000).should eq(20)
+    expect(f.at(0)).to eq(20)
+    expect(f.at(-1000)).to eq(20)
+    expect(f.at(1000)).to eq(20)
   end
 end
 
 describe Function::Linear do
   it 'should evaluate along the line going between the two initial points' do
     f = Function::Linear.new([5,10],[7,11])
-    f.at(4).should eq(9.5)
-    f.at(5).should eq(10)
-    f.at(6).should eq(10.5)
-    f.at(7).should eq(11)
-    f.at(8).should eq(11.5)
+    expect(f.at(4)).to eq(9.5)
+    expect(f.at(5)).to eq(10)
+    expect(f.at(6)).to eq(10.5)
+    expect(f.at(7)).to eq(11)
+    expect(f.at(8)).to eq(11.5)
   end
 end
 
 describe Function::Sigmoid do
   it 'should evaluate along the line going between the two initial points' do
     f = Function::Sigmoid.new([5,10],[7,11])
-    f.at(4).should be < 10
-    f.at(5).should eq(10)
-    f.at(6).should eq(10.5)
-    f.at(7).should eq(11)
-    f.at(8).should be > 11
+    expect(f.at(4)).to be < 10
+    expect(f.at(5)).to eq(10)
+    expect(f.at(6)).to eq(10.5)
+    expect(f.at(7)).to eq(11)
+    expect(f.at(8)).to be > 11
   end
-  
+
   describe '.find_y0' do
     it 'should return the starting y-value for the given sigmoid domain' do
       x0, x1 = 3, 6
@@ -37,7 +37,7 @@ describe Function::Sigmoid do
       f = Function::Sigmoid.new([x0,y0],[x1,y1])
       pt = [4,f.at(4)]
       y0_ = Function::Sigmoid.find_y0(x0..x1, pt, y1)
-      y0_.should eq(y0)
+      expect(y0_).to eq(y0)
     end
   end
 end

data/spec/notation/util/transition_spec.rb

@@ -5,47 +5,47 @@ describe Transition do
     context 'zero-length domain' do
       it 'should create one piece' do
         t = Transition.new(Function::Constant.new(3),5..5)
-        t.pieces.size.should eq(1)
+        expect(t.pieces.size).to eq(1)
       end
     end
-    
+
     context 'positive-length domain' do
       it 'should create two pieces' do
         t = Transition.new(Function::Linear.new([0,0],[2,1]),3..5)
-        t.pieces.size.should eq(2)
+        expect(t.pieces.size).to eq(2)
       end
     end
   end
-  
+
   describe '#at' do
     before :all do
       @f = Function::Linear.new([0,0],[2,1])
       @d = 3..5
       @t = Transition.new(@f,@d)
     end
-    
+
     context 'given value before transition domain starts' do
       it 'should raise DomainError' do
         expect { @t.at(@d.first - 1e-5) }.to raise_error(DomainError)
         expect { @t.at(@d.first - 1e5) }.to raise_error(DomainError)
       end
     end
-    
+
     context 'given value in transition domain' do
       it 'should not raise DomainError' do
         @d.entries.each {|x| expect { @t.at(x) }.to_not raise_error }
       end
-      
+
       it 'should calculate return value using the transition function' do
-        @d.entries.each {|x| @t.at(x).should eq(@f.at(x)) }
+        @d.entries.each {|x| expect(@t.at(x)).to eq(@f.at(x)) }
       end
     end
-    
+
     context 'given value after transition domain' do
       it 'should return same value as at the end of transition domain' do
-        @t.at(@d.last + 1e-5).should eq(@t.at(@d.last))
-        @t.at(@d.last + 1e5).should eq(@t.at(@d.last))
+        expect(@t.at(@d.last + 1e-5)).to eq(@t.at(@d.last))
+        expect(@t.at(@d.last + 1e5)).to eq(@t.at(@d.last))
       end
     end
   end
-end
+end

data/spec/notation/util/value_computer_spec.rb

@@ -7,68 +7,68 @@ describe ValueComputer do
       @lin_change = Change::Gradual.linear(0.6, 1.0)
       @sigm_change = Change::Gradual.sigmoid(0.6, 1.0)
     end
-    
+
     context "constant value" do
       before :each do
         @comp = ValueComputer.new 0.5
       end
-      
+
       it "should always return default value if no changes are given" do
         [ValueComputer::DOMAIN_MIN, -1000, 0, 1, 5, 100, 10000].each do |offset|
-          @comp.at(offset).should eq(0.5)
+          expect(@comp.at(offset)).to eq(0.5)
         end
       end
     end
-    
+
     context "one change, no transition" do
       before :each do
         @comp = ValueComputer.new 0.5, 1.0 => @immed_change
       end
-      
+
       it "should be the default value just before the first change" do
-        @comp.at(0.999).should eq(0.5)
+        expect(@comp.at(0.999)).to eq(0.5)
       end
-          
+
       it "should transition to the second value immediately" do
-        @comp.at(1.0).should eq(0.6)
+        expect(@comp.at(1.0)).to eq(0.6)
       end
 
       it "should be the first value for all time before" do
-        @comp.at(ValueComputer::DOMAIN_MIN).should eq(0.5)
+        expect(@comp.at(ValueComputer::DOMAIN_MIN)).to eq(0.5)
       end
-      
+
       it "should be at the second value for all time after" do
-        @comp.at(100_000).should eq(0.6)
+        expect(@comp.at(100_000)).to eq(0.6)
       end
     end
-    
+
     context "one change, linear transition" do
       before :each do
         @comp = ValueComputer.new 0.2, 1.0 => @lin_change
       end
-      
+
       it "should be the first (starting) value just before the second value" do
-        @comp.at(0.999).should eq(0.2)
+        expect(@comp.at(0.999)).to eq(0.2)
       end
-          
+
       it "should be the first (starting) value exactly at the second value" do
-        @comp.at(1.0).should eq(0.2)
+        expect(@comp.at(1.0)).to eq(0.2)
       end
-    
+
       it "should be 1/4 to the second value after 1/4 transition duration has elapsed" do
-        @comp.at(Rational(5,4).to_f).should eq(0.3)
+        expect(@comp.at(Rational(5,4).to_f)).to eq(0.3)
       end
-    
+
       it "should be 1/2 to the second value after 1/2 transition duration has elapsed" do
-        @comp.at(Rational(6,4).to_f).should eq(0.4)
+        expect(@comp.at(Rational(6,4).to_f)).to eq(0.4)
       end
-    
+
       it "should be 3/4 to the second value after 3/4 transition duration has elapsed" do
-        @comp.at(Rational(7,4).to_f).should eq(0.5)
+        expect(@comp.at(Rational(7,4).to_f)).to eq(0.5)
       end
-    
+
       it "should be at the second value after transition duration has elapsed" do
-        @comp.at(Rational(8,4).to_f).should eq(0.6)
+        expect(@comp.at(Rational(8,4).to_f)).to eq(0.6)
       end
     end
 
@@ -76,27 +76,26 @@ describe ValueComputer do
       before :each do
         @comp = ValueComputer.new 0.2, 1.0 => @sigm_change
       end
-      
+
       it "should be the first (starting) value just before the second value" do
-        @comp.at(0.999).should eq(0.2)
+        expect(@comp.at(0.999)).to eq(0.2)
       end
-          
+
       it "should be the first (starting) value exactly at the second value" do
-        @comp.at(1.0).should eq(0.2)
+        expect(@comp.at(1.0)).to eq(0.2)
       end
-    
+
       it "should be 1/2 to the second value after 1/2 transition duration has elapsed" do
-        @comp.at(1.5).should be_within(1e-5).of(0.4)
+        expect(@comp.at(1.5)).to be_within(1e-5).of(0.4)
       end
-    
+
       it "should be at the second value exactly where transition duration has elapsed" do
-        @comp.at(2).should eq(0.6)
+        expect(@comp.at(2)).to eq(0.6)
       end
-      
+
       it "should be at the second value just after transition duration has elapsed" do
-        @comp.at(2.001).should eq(0.6)
-      end      
+        expect(@comp.at(2.001)).to eq(0.6)
+      end
     end
   end
 end
-

data/spec/performance/conversion/glissando_converter_spec.rb

@@ -15,27 +15,27 @@ describe GlissandoConverter do
       ].each do |start,finish|
         context "start at #{start.to_s}, target #{finish.to_s}" do
           pitches = GlissandoConverter.glissando_pitches(start,finish)
-          
+
           it 'should begin with start pitch' do
-            pitches.first.should eq(start)
+            expect(pitches.first).to eq(start)
           end
-          
+
           it 'should move up to next whole (zero-cent) pitches' do
             (1...pitches.size).each do |i|
-              pitches[i].cent.should eq(0)
-              pitches[i].diff(pitches[i-1]).should be <= 1
+              expect(pitches[i].cent).to eq(0)
+              expect(pitches[i].diff(pitches[i-1])).to be <= 1
             end
           end
-          
+
           it 'should end on the whole (zero-cent) pitch below target pitch' do
-            pitches.last.cent.should eq(0)
+            expect(pitches.last.cent).to eq(0)
             diff = finish.total_cents - pitches.last.total_cents
-            diff.should be <= 100
+            expect(diff).to be <= 100
           end
         end
       end
     end
-    
+
     context 'start pitch > target pitch' do
       [
         [B3,F3],
@@ -48,46 +48,46 @@ describe GlissandoConverter do
       ].each do |start,finish|
         context "start at #{start.to_s}, target #{finish.to_s}" do
           pitches = GlissandoConverter.glissando_pitches(start,finish)
-          
+
           it 'should move down to next whole (zero-cent) pitches' do
             (1...pitches.size).each do |i|
-              pitches[i].cent.should eq(0)
-              pitches[i-1].diff(pitches[i]).should be <= 1
+              expect(pitches[i].cent).to eq(0)
+              expect(pitches[i-1].diff(pitches[i])).to be <= 1
             end
           end
-          
+
           it 'should end on the whole (zero-cent) pitch above target pitch' do
-            pitches.last.cent.should eq(0)
+            expect(pitches.last.cent).to eq(0)
             diff = pitches.last.total_cents - finish.total_cents
-            diff.should be <= 100
+            expect(diff).to be <= 100
           end
 
         end
       end
     end
   end
-  
+
   describe '.glissando_elements' do
     before :all do
       @dur = Rational(3,2)
       @att = Attack::TENUTO
       @els = GlissandoConverter.glissando_elements(C4,A4,@dur,@att)
     end
-    
+
     it 'should return an array of NoteSequence::Element objects' do
-      @els.each {|el| el.should be_a NoteSequence::Element }
+      @els.each {|el| expect(el).to be_a NoteSequence::Element }
     end
-    
+
     it 'should split up duration among elements' do
       sum = @els.map {|el| el.duration }.inject(0,:+)
-      sum.should eq(@dur)
+      expect(sum).to eq(@dur)
     end
-    
+
     it 'should set attack as given for each element' do
       els = GlissandoConverter.glissando_elements(C4,A4,1,Attack::TENUTO)
-      els.each {|el| el.attack.should eq(Attack::TENUTO) }
+      els.each {|el| expect(el.attack).to eq(Attack::TENUTO) }
       els = GlissandoConverter.glissando_elements(C4,A4,1,Attack::ACCENT)
-      els.each {|el| el.attack.should eq(Attack::ACCENT) }
+      els.each {|el| expect(el.attack).to eq(Attack::ACCENT) }
     end
   end
-end
+end

data/spec/performance/conversion/note_sequence_extractor_spec.rb

@@ -6,15 +6,15 @@ describe NoteSequenceExtractor do
     it 'should clone original notes' do
       notes = [ Note.quarter([C2]), Note.half, Note.half ]
       extr = NoteSequenceExtractor.new(notes)
-      extr.notes[0].should eq(notes[0])
+      expect(extr.notes[0]).to eq(notes[0])
       notes[0].transpose!(1)
-      extr.notes[0].should_not eq(notes[0])
+      expect(extr.notes[0]).to_not eq(notes[0])
     end
 
     it 'should maintain the same number of notes' do
       extr = NoteSequenceExtractor.new(
         [ Note.quarter, Note.half, Note.half ])
-      extr.notes.size.should eq 3
+      expect(extr.notes.size).to eq 3
     end
 
     it 'should remove any links where the source pitch does not exist in the note' do
@@ -22,19 +22,19 @@ describe NoteSequenceExtractor do
         [ Note.quarter([E4], links: {C4 => Link::Tie.new}),
           Note.quarter([C4,E4]) ]
       )
-      extr.notes[0].links.should_not have_key(C4)
+      expect(extr.notes[0].links).to_not have_key(C4)
 
       extr = NoteSequenceExtractor.new(
         [ Note.quarter([E4], links: {C4 => Link::Glissando.new(G4)}),
           Note.quarter([C4,E4,G4]) ]
       )
-      extr.notes[0].links.should_not have_key(C4)
+      expect(extr.notes[0].links).to_not have_key(C4)
 
       extr = NoteSequenceExtractor.new(
         [ Note.quarter([E4], links: {C4 => Link::Portamento.new(G4)}),
           Note.quarter([C4,E4,G4]) ]
       )
-      extr.notes[0].links.should_not have_key(C4)
+      expect(extr.notes[0].links).to_not have_key(C4)
     end
 
     it 'should keep glissando/portamento links even when the target pitch does not exist in the next note.' do
@@ -42,13 +42,13 @@ describe NoteSequenceExtractor do
         [ Note.quarter([C4], links: {C4 => Link::Glissando.new(G4)}),
           Note.quarter([E4]) ]
       )
-      extr.notes[0].links.should have_key(C4)
+      expect(extr.notes[0].links).to have_key(C4)
 
       extr = NoteSequenceExtractor.new(
         [ Note.quarter([C4], links: {C4 => Link::Portamento.new(G4)}),
           Note.quarter([E4]) ]
       )
-      extr.notes[0].links.should have_key(C4)
+      expect(extr.notes[0].links).to have_key(C4)
     end
   end
 
@@ -56,7 +56,7 @@ describe NoteSequenceExtractor do
     context 'empty note array' do
       it 'should return empty' do
         seqs = NoteSequenceExtractor.new([]).extract_sequences
-        seqs.should be_empty
+        expect(seqs).to be_empty
       end
     end
 
@@ -64,7 +64,7 @@ describe NoteSequenceExtractor do
       it 'should return empty' do
         notes = [ Note::quarter, Note::quarter ]
         seqs = NoteSequenceExtractor.new(notes).extract_sequences
-        seqs.should be_empty
+        expect(seqs).to be_empty
       end
     end
 
@@ -75,19 +75,19 @@ describe NoteSequenceExtractor do
       end
 
       it 'should return array with one sequence' do
-        @seqs.size.should eq 1
+        expect(@seqs.size).to eq 1
       end
 
       it 'should have start offset of 0' do
-        @seqs[0].start.should eq 0
+        expect(@seqs[0].start).to eq 0
       end
 
       it 'should have stop offset <= note duration' do
-        @seqs[0].stop.should be <= @note.duration
+        expect(@seqs[0].stop).to be <= @note.duration
       end
     end
 
-    context 'array with two slurred notes, single pitch' do
+    context 'array with two slurred notes, single pitch each' do
       before :all do
         @notes = [ Note.quarter([C5], marks: [BEGIN_SLUR]),
                    Note.quarter([D5], marks: [END_SLUR]) ]
@@ -95,15 +95,15 @@ describe NoteSequenceExtractor do
       end
 
       it 'should return array with one sequence' do
-        @seqs.size.should eq 1
+        expect(@seqs.size).to eq 1
       end
 
       it 'should have start offset of 0' do
-        @seqs[0].start.should eq 0
+        expect(@seqs[0].start).to eq 0
       end
 
       it 'should have stop offset <= combined duration of the two notes' do
-        @seqs[0].stop.should be <= (@notes[0].duration + @notes[1].duration)
+        expect(@seqs[0].stop).to be <= (@notes[0].duration + @notes[1].duration)
       end
     end
 
@@ -114,30 +114,30 @@ describe NoteSequenceExtractor do
       end
 
       it 'should return array with as many sequences as pitches' do
-        @seqs.size.should eq @note.pitches.size
+        expect(@seqs.size).to eq @note.pitches.size
       end
 
       it 'should start the sequences at 0' do
-        @seqs.each {|s| s.start.should eq(0) }
+        @seqs.each {|s| expect(s.start).to eq(0) }
       end
 
       it 'should end each sequence at or before note duration' do
-        @seqs.each {|s| s.stop.should be <= @note.duration }
+        @seqs.each {|s| expect(s.stop).to be <= @note.duration }
       end
 
       it 'should put one element in each seq' do
-        @seqs.each {|s| s.elements.size.should eq(1) }
+        @seqs.each {|s| expect(s.elements.size).to eq(1) }
       end
 
       it 'should assign a different pitch to each' do
-        @seqs.map {|seq| seq.elements.first.pitch }.sort.should eq @note.pitches.sort
+        expect(@seqs.map {|seq| seq.elements.first.pitch }.sort).to eq @note.pitches.sort
       end
     end
 
     context 'array with multiple notes and links' do
       before :all do
         @notes = [
-          Note.quarter([C3,E3], links: { C3 => Link::Tie.new, 
+          Note.quarter([C3,E3], links: { C3 => Link::Tie.new,
             E3 => Link::Glissando.new(G3)}),
           Note.eighth([C3,G3])
         ]
@@ -145,22 +145,22 @@ describe NoteSequenceExtractor do
       end
 
       it 'should create a single sequence for linked notes' do
-        @seqs.size.should eq(2)
+        expect(@seqs.size).to eq(2)
       end
 
       it 'should set first element pitch to match first note' do
-        @seqs[0].elements.first.pitch.should eq(@notes[0].pitches[0])
-        @seqs[1].elements.first.pitch.should eq(@notes[0].pitches[1])
+        expect(@seqs[0].elements.first.pitch).to eq(@notes[0].pitches[0])
+        expect(@seqs[1].elements.first.pitch).to eq(@notes[0].pitches[1])
       end
 
       it 'should collapse tie link to a single element' do
-        @seqs[0].elements.size.should eq(1)
-        @seqs[0].duration.should be <= (@notes[0].duration + @notes[1].duration)
+        expect(@seqs[0].elements.size).to eq(1)
+        expect(@seqs[0].duration).to be <= (@notes[0].duration + @notes[1].duration)
       end
 
       it 'should expand the glissando into multiple elements' do
-        @seqs[1].elements.size.should be > 2
-        @seqs[1].duration.should be <= (@notes[0].duration + @notes[1].duration)
+        expect(@seqs[1].elements.size).to be > 2
+        expect(@seqs[1].duration).to be <= (@notes[0].duration + @notes[1].duration)
       end
     end
 
@@ -171,15 +171,15 @@ describe NoteSequenceExtractor do
       end
 
       it 'should produce one sequence' do
-        @seqs.size.should eq(1)
+        expect(@seqs.size).to eq(1)
       end
 
       it 'should include pitches up to (not including) target pitch' do
-        @seqs[0].elements.map{|e| e.pitch}.should include(D3,Eb3,E3,F3,Gb3)
+        expect(@seqs[0].elements.map{|e| e.pitch}).to include(D3,Eb3,E3,F3,Gb3)
       end
 
       it 'should produce sequence with duration <= note duration' do
-        @seqs[0].duration.should be <= @note.duration
+        expect(@seqs[0].duration).to be <= @note.duration
       end
     end
 
@@ -190,15 +190,15 @@ describe NoteSequenceExtractor do
       end
 
       it 'should produce one sequence' do
-        @seqs.size.should eq(1)
+        expect(@seqs.size).to eq(1)
       end
 
       it 'should include pitches down to (not including) target pitch' do
-        @seqs[0].elements.map{|e| e.pitch}.should include(D3,Db3,C3,B2,Bb2)
+        expect(@seqs[0].elements.map{|e| e.pitch}).to include(D3,Db3,C3,B2,Bb2)
       end
 
       it 'should produce sequence with duration <= note duration' do
-        @seqs[0].duration.should be <= @note.duration
+        expect(@seqs[0].duration).to be <= @note.duration
       end
     end
 
@@ -210,15 +210,15 @@ describe NoteSequenceExtractor do
       end
 
       it 'should produce a single sequence' do
-        @seqs.size.should eq(1)
+        expect(@seqs.size).to eq(1)
       end
 
       it 'should includes pitches up through target pitch' do
-        @seqs[0].elements.map{|e| e.pitch}.should include(D3,Eb3,E3,F3,Gb3,G3)
+        expect(@seqs[0].elements.map{|e| e.pitch}).to include(D3,Eb3,E3,F3,Gb3,G3)
       end
 
       it 'should produce sequence with duration <= note1dur + note2dur' do
-        @seqs[0].duration.should be <= (@notes[0].duration + @notes[1].duration)
+        expect(@seqs[0].duration).to be <= (@notes[0].duration + @notes[1].duration)
       end
     end