musicality 0.11.1 → 0.12.0

data/spec/performance/conversion/portamento_converter_spec.rb

@@ -14,21 +14,21 @@ describe PortamentoConverter do
       ].each do |start,finish,step_size|
         context "start at #{start.to_s}, end at #{finish.to_s}" do
           pitches = PortamentoConverter.portamento_pitches(start,finish,step_size)
-          
+
           it 'should begin at start pitch' do
-            pitches.first.should eq(start)
+            expect(pitches.first).to eq(start)
           end
-          
+
           it 'should space pitches using given cent step size' do
             (1...pitches.size).each do |i|
               diff = pitches[i].total_cents - pitches[i-1].total_cents
-              diff.should eq(step_size)
+              expect(diff).to eq(step_size)
             end
           end
-          
+
           it 'should end where one more step would be >= target pitch' do
             diff = finish.total_cents - pitches.last.total_cents
-            diff.should be <= step_size
+            expect(diff).to be <= step_size
           end
         end
       end
@@ -44,50 +44,50 @@ describe PortamentoConverter do
       ].each do |start,finish,step_size|
         context "start at #{start.to_s}, end at #{finish.to_s}" do
           pitches = PortamentoConverter.portamento_pitches(start,finish,step_size)
-          
+
           it 'should begin at start pitch' do
-            pitches.first.should eq(start)
+            expect(pitches.first).to eq(start)
           end
-          
+
           it 'should space pitches using negative of given cent step size' do
             (1...pitches.size).each do |i|
               diff = pitches[i-1].total_cents - pitches[i].total_cents
-              diff.should eq(step_size)
+              expect(diff).to eq(step_size)
             end
           end
-          
+
           it 'should end where one more step would be <= target pitch' do
             diff = pitches.last.total_cents - finish.total_cents
-            diff.should be <= step_size
+            expect(diff).to be <= step_size
           end
         end
       end
     end
   end
-  
+
   describe '.portamento_elements' do
     before :all do
       @dur = Rational(3,2)
       @att = Attack::NONE
       @els = PortamentoConverter.portamento_elements(C4,F4,25,@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 first element only and set others to NONE' do
       els = PortamentoConverter.portamento_elements(C4,D4,10,1,Attack::ACCENT)
-      els.first.attack.should eq(Attack::ACCENT)
-      els[1..-1].each {|el| el.attack.should eq(Attack::NONE) }
+      expect(els.first.attack).to eq(Attack::ACCENT)
+      els[1..-1].each {|el| expect(el.attack).to eq(Attack::NONE) }
       els = PortamentoConverter.portamento_elements(C4,D4,10,1,Attack::TENUTO)
-      els.first.attack.should eq(Attack::TENUTO)
-      els[1..-1].each {|el| el.attack.should eq(Attack::NONE) }
+      expect(els.first.attack).to eq(Attack::TENUTO)
+      els[1..-1].each {|el| expect(el.attack).to eq(Attack::NONE) }
     end
   end
-end
+end

data/spec/performance/midi/midi_util_spec.rb

@@ -4,38 +4,38 @@ describe MidiUtil do
   describe '.pitch_to_notenum' do
     context 'given C4' do
       it 'should return 60' do
-        MidiUtil.pitch_to_notenum(C4).should eq(60)
+        expect(MidiUtil.pitch_to_notenum(C4)).to eq(60)
       end
     end
-    
+
     context 'given A4' do
       it 'should return 69' do
-        MidiUtil.pitch_to_notenum(A4).should eq(69)
+        expect(MidiUtil.pitch_to_notenum(A4)).to eq(69)
       end
     end
-    
+
     context 'given octave below C0' do
       it 'should return 0' do
-        MidiUtil.pitch_to_notenum(Pitch.new(octave:-1)).should eq(0)
+        expect(MidiUtil.pitch_to_notenum(Pitch.new(octave:-1))).to eq(0)
       end
     end
-    
+
     context 'given G9' do
       it 'should return 127' do
-        MidiUtil.pitch_to_notenum(G9).should eq(127)
+        expect(MidiUtil.pitch_to_notenum(G9)).to eq(127)
       end
     end
-    
+
     context 'given pitch between C-1 to G9 range' do
       it 'should pitch diff from C4 should equal notenum diff' do
         c4_nn = MidiUtil.pitch_to_notenum(C4)
          [C2,D2,Eb2,F2,A2,Bb3,C3,G3,Gb4,F5,A5,Bb5,C6].each do |pitch|
           nn = MidiUtil.pitch_to_notenum(pitch)
-          C4.diff(pitch).should eq(c4_nn - nn)
+          expect(C4.diff(pitch)).to eq(c4_nn - nn)
         end
       end
     end
-    
+
     context 'given pitch outside C-1 to G9 range' do
       it 'should raise error' do
         expect { MidiUtil.pitch_to_notenum(Pitch.new(octave:-2)) }.to raise_error(KeyError)
@@ -47,103 +47,103 @@ describe MidiUtil do
   describe '.notenum_to_pitch' do
     context 'given 60' do
       it 'should return C4' do
-        MidiUtil.notenum_to_pitch(60).should eq(C4)
+        expect(MidiUtil.notenum_to_pitch(60)).to eq(C4)
       end
     end
-    
+
     context 'given 69' do
       it 'should return A4' do
-        MidiUtil.notenum_to_pitch(69).should eq(A4)
+        expect(MidiUtil.notenum_to_pitch(69)).to eq(A4)
       end
     end
-    
+
     context 'given 0' do
       it 'should return octave below C0' do
-        MidiUtil.notenum_to_pitch(0).should eq(Pitch.new(octave:-1))
+        expect(MidiUtil.notenum_to_pitch(0)).to eq(Pitch.new(octave:-1))
       end
     end
-    
+
     context 'given 127' do
       it 'should return G9' do
-        MidiUtil.notenum_to_pitch(127).should eq(G9)
+        expect(MidiUtil.notenum_to_pitch(127)).to eq(G9)
       end
-    end    
+    end
   end
-  
+
   describe '.dynamic_to_volume' do
     context 'given 0' do
       it 'should return 0' do
-        MidiUtil.dynamic_to_volume(0).should eq(0)
+        expect(MidiUtil.dynamic_to_volume(0)).to eq(0)
       end
     end
-    
+
     context 'given 1' do
       it 'should return 0' do
-        MidiUtil.dynamic_to_volume(1).should eq(127)
+        expect(MidiUtil.dynamic_to_volume(1)).to eq(127)
       end
     end
-    
+
     context 'given 0.5' do
       it 'should return 64' do
-        MidiUtil.dynamic_to_volume(0.5).should eq(64)
+        expect(MidiUtil.dynamic_to_volume(0.5)).to eq(64)
       end
     end
   end
-  
+
   describe 'note_velocity' do
     context 'given Attack::NORMAL' do
       it 'should return a value at least that of when given Attack::NONE' do
-        MidiUtil.note_velocity(Attack::NORMAL).should be >= MidiUtil.note_velocity(Attack::NONE)
+        expect(MidiUtil.note_velocity(Attack::NORMAL)).to be >= MidiUtil.note_velocity(Attack::NONE)
       end
 
       it 'should return a value between 0 and 127' do
-        MidiUtil.note_velocity(Attack::NORMAL).should be_between(0,127)
+        expect(MidiUtil.note_velocity(Attack::NORMAL)).to be_between(0,127)
       end
     end
 
     context 'given Attack::TENUTO' do
       it 'should return a higher value than when given Attack::NORMAL' do
-        MidiUtil.note_velocity(Attack::TENUTO).should be > MidiUtil.note_velocity(Attack::NORMAL)
+        expect(MidiUtil.note_velocity(Attack::TENUTO)).to be > MidiUtil.note_velocity(Attack::NORMAL)
       end
-      
+
       it 'should return a value between 0 and 127' do
-        MidiUtil.note_velocity(Attack::TENUTO).should be_between(0,127)
+        expect(MidiUtil.note_velocity(Attack::TENUTO)).to be_between(0,127)
       end
     end
-    
+
     context 'given Attack::ACCENT' do
       it 'should return a higher value than when given Attack::TENUTO' do
-        MidiUtil.note_velocity(Attack::ACCENT).should be > MidiUtil.note_velocity(Attack::TENUTO)
+        expect(MidiUtil.note_velocity(Attack::ACCENT)).to be > MidiUtil.note_velocity(Attack::TENUTO)
       end
 
       it 'should return a value between 0 and 127' do
-        MidiUtil.note_velocity(Attack::ACCENT).should be_between(0,127)
+        expect(MidiUtil.note_velocity(Attack::ACCENT)).to be_between(0,127)
       end
     end
   end
-  
+
   describe '.delta' do
     context 'given 1/4' do
       it 'should return the given ppqn' do
-        MidiUtil.delta(Rational(1,4),20).should eq(20)
+        expect(MidiUtil.delta(Rational(1,4),20)).to eq(20)
       end
     end
-    
+
     context 'given 1/2' do
       it 'should return twice the given ppqn' do
-        MidiUtil.delta(Rational(1,2),20).should eq(40)
+        expect(MidiUtil.delta(Rational(1,2),20)).to eq(40)
       end
     end
-    
+
     context 'given 1/8' do
       it 'should return half the given ppqn' do
-        MidiUtil.delta(Rational(1,8),20).should eq(10)
+        expect(MidiUtil.delta(Rational(1,8),20)).to eq(10)
       end
     end
-    
+
     it 'should return an integer' do
       (0.1...1.1).step(0.1).each do |dur|
-        MidiUtil.delta(dur,100).should be_an(Integer)
+        expect(MidiUtil.delta(dur,100)).to be_an(Integer)
       end
     end
   end

data/spec/performance/midi/part_sequencer_spec.rb

@@ -12,30 +12,30 @@ describe PartSequencer do
       @program_num = 22
       @track = PartSequencer.new(part).make_midi_track(@midi_seq,@part_name,@channel,@ppqn,@program_num)
     end
-    
+
     it 'should return MIDI::Track' do
-      @track.should be_a MIDI::Track
+      expect(@track).to be_a MIDI::Track
     end
-    
+
     it 'should assign part name to track name' do
-      @track.name.should eq(@part_name)
+      expect(@track.name).to eq(@part_name)
     end
-    
+
     it 'should assign program number (less one) via ProgramChange event' do
       event = @track.events.select { |x| x.is_a? MIDI::ProgramChange }.first
-      event.program.should eq(@program_num-1)
+      expect(event.program).to eq(@program_num-1)
     end
-    
+
     it 'should assign the given channel number to all channel events' do
       @track.events.each do |event|
         if event.is_a? MIDI::ChannelEvent
-          event.channel.should eq(@channel)
+          expect(event.channel).to eq(@channel)
         end
       end
     end
-    
+
     it 'should not add the track to the given midi seq' do
-      @midi_seq.tracks.should_not include(@track)
+      expect(@midi_seq.tracks).to_not include(@track)
     end
   end
 end

data/spec/performance/midi/score_sequencer_spec.rb

@@ -3,12 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe ScoreSequencer do
   describe '#initialize' do
   end
-  
+
   describe '#make_midi_seq' do
     before :all do
       @part1_name = "abc"
       @part2_name = "def"
-      @part1 = Part.new(Dynamics::PP, notes: "/4C4 /4D4 /8 /8D4 /8E4 3/8C4".to_notes * 2, 
+      @part1 = Part.new(Dynamics::PP, notes: "/4C4 /4D4 /8 /8D4 /8E4 3/8C4".to_notes * 2,
         settings: [ MidiSettings::ELECTRIC_BASS_PICK ])
       @part2 = Part.new(Dynamics::FF, notes: "/4E4 3/4F4 /4E4".to_notes * 2,
         settings: [ MidiSettings::ELECTRIC_GUITAR_JAZZ ])
@@ -16,35 +16,35 @@ describe ScoreSequencer do
                                 parts: {@part1_name => @part1, @part2_name => @part2})
       @midi_seq = ScoreSequencer.new(@score).make_midi_seq
     end
-    
+
     it 'should return MIDI::Sequence' do
-      @midi_seq.should be_a MIDI::Sequence
+      expect(@midi_seq).to be_a MIDI::Sequence
     end
-    
+
     it 'should have 1 track for each part, plus one for score meta events' do
-      @midi_seq.tracks.size.should eq(@score.parts.size + 1)
+      expect(@midi_seq.tracks.size).to eq(@score.parts.size + 1)
     end
-    
+
     it 'should add a midi track for each part' do
-      @midi_seq.tracks[1].name.should eq(@part1_name)
-      @midi_seq.tracks[2].name.should eq(@part2_name)
+      expect(@midi_seq.tracks[1].name).to eq(@part1_name)
+      expect(@midi_seq.tracks[2].name).to eq(@part2_name)
     end
-    
+
     it 'should assign program number (starts at 0) from part midi program number (starts at 1)' do
       prog_event = @midi_seq.tracks[1].events.select {|x| x.is_a? MIDI::ProgramChange }.first
-      prog_event.program.should eq(@part1.midi_settings.program - 1)
+      expect(prog_event.program).to eq(@part1.midi_settings.program - 1)
 
       prog_event = @midi_seq.tracks[2].events.select {|x| x.is_a? MIDI::ProgramChange }.first
-      prog_event.program.should eq(@part2.midi_settings.program - 1)
+      expect(prog_event.program).to eq(@part2.midi_settings.program - 1)
     end
-    
+
     it 'should assign different channel to each part track' do
       chs_so_far = []
       [ @midi_seq.tracks[1], @midi_seq.tracks[2] ].each do |track|
         channel_events = track.events.select {|x| x.is_a? MIDI::ChannelEvent }
         chs = channel_events.map {|event| event.channel }.uniq
-        chs.size.should eq 1
-        chs_so_far.should_not include(chs[0])
+        expect(chs.size).to eq 1
+        expect(chs_so_far).to_not include(chs[0])
         chs_so_far.push chs[0]
       end
     end

data/spec/performance/midi/score_sequencing_spec.rb

@@ -16,7 +16,7 @@ describe Score::Timed do
   describe '#to_midi_seq' do
     it 'should produce a MIDI::Sequence' do
       seq = @score.to_midi_seq
-      seq.should be_a MIDI::Sequence
+      expect(seq).to be_a MIDI::Sequence
     end
   end
 end
@@ -39,7 +39,7 @@ describe Score::Tempo do
   describe '#to_midi_seq' do
     it 'should produce a MIDI::Sequence' do
       seq = @score.to_midi_seq 200
-      seq.should be_a MIDI::Sequence
+      expect(seq).to be_a MIDI::Sequence
     end
   end
 end

data/spec/performance/util/optimization_spec.rb

@@ -7,14 +7,14 @@ describe Optimization do
         [ C4, Bb4, G2, A3 ].each do |p1|
           [ C4, Bb4, G2, A3 ].each do |p2|
             sol = Optimization.linking([p1], [p2])
-            sol.size.should eq 1
-            sol.should have_key p1
-            sol[p1].should eq p2
+            expect(sol.size).to eq 1
+            expect(sol).to have_key p1
+            expect(sol[p1]).to eq p2
           end
         end
       end
     end
-    
+
     context 'two unlinked, one untargeted' do
       it 'should map the closest unlinked to the one untargeted' do
         unlinked = [C4,G4]
@@ -26,11 +26,11 @@ describe Optimization do
           [Bb3] => {C4 => Bb3}
         }.each do |untargeted, expected_map|
           sol = Optimization.linking(unlinked, untargeted)
-          sol.should eq expected_map
+          expect(sol).to eq expected_map
         end
       end
     end
-    
+
     context 'one unlinked, two untargeted' do
       it 'should map the one unlinked to the closest untargeted' do
         unlinked = [C4]
@@ -41,11 +41,11 @@ describe Optimization do
           [G3,G4] => {C4 => G3}
         }.each do |untargeted, expected_map|
           sol = Optimization.linking(unlinked, untargeted)
-          sol.should eq expected_map
+          expect(sol).to eq expected_map
         end
       end
     end
-    
+
     context 'many unlinked, many untargeted' do
       it 'should map [unlinked.size, untargeted.size].min unlinked to untargeted, such that total pitch diffs is minimized' do
         {
@@ -65,7 +65,7 @@ describe Optimization do
         }.each do |unlinked_untargeted, expected_map|
           unlinked,untargeted = unlinked_untargeted
           sol = Optimization.linking(unlinked, untargeted)
-          sol.should eq expected_map
+          expect(sol).to eq expected_map
         end
       end
     end

data/spec/printing/note_engraving_spec.rb

@@ -6,7 +6,7 @@ describe Note do
       it 'should return empty array' do
         [1,2,3,4,7,11].each do |dur|
           subdurs = Note.new(dur).fractional_subdurs(Rational(1,32))
-          subdurs.should be_empty
+          expect(subdurs).to be_empty
         end
       end
     end
@@ -23,11 +23,11 @@ describe Note do
           subdurs2 = n.fractional_subdurs(Rational(1,512))
 
           it 'should return descending power-of-two fractions' do
-            subdurs2.should eq subdurs2.sort.reverse
+            expect(subdurs2).to eq subdurs2.sort.reverse
           end
 
           it 'should return fractions that sum to note duration' do
-            subdurs2.inject(0.to_r,:+).should eq(dur)
+            expect(subdurs2.inject(0.to_r,:+)).to eq(dur)
           end
         end
       end
@@ -44,7 +44,7 @@ describe Note do
         subdurs2 = n.fractional_subdurs(Rational(1,1024))
 
         it 'should return fractions that sum to fractional note duration' do
-          subdurs2.inject(0.to_r,:+).should eq(dur - dur.to_i)
+          expect(subdurs2.inject(0.to_r,:+)).to eq(dur - dur.to_i)
         end
       end
     end
@@ -83,7 +83,7 @@ describe Note do
     #     it 'should return a string with "r" plus the duration denominator' do
     #       [1,0.5,0.25,0.125,0.0625].each do |dur|
     #         n = Note.new(dur.to_r)
-    #         n.to_lilypond.should eq("r" + n.duration.denominator.to_s)
+    #         expect(n.to_lilypond).to eq("r" + n.duration.denominator.to_s)
     #       end
     #     end
     #   end
@@ -92,7 +92,7 @@ describe Note do
     #     it 'should return a string with "r" plus half the duration denominator plus a "."' do
     #       [0.75,0.375].each do |dur|
     #         n = Note.new(dur.to_r)
-    #         n.to_lilypond.should eq("r" + (n.duration.denominator/2).to_s + ".")
+    #         expect(n.to_lilypond).to eq("r" + (n.duration.denominator/2).to_s + ".")
     #       end
     #     end
     #   end
@@ -108,9 +108,9 @@ describe Note do
     #         dur = subdurs.inject(0.to_r,:+)
     #         n = Note.new(dur)
     #         strs = n.to_lilypond.split
-    #         strs.size.should eq subdurs.size
+    #         expect(strs.size).to eq subdurs.size
     #         strs.each_with_index do |str,i|
-    #           str.should eq("r" + subdurs[i].to_r.denominator.to_s)
+    #           expect(str).to eq("r" + subdurs[i].to_r.denominator.to_s)
     #         end
     #       end
     #     end
@@ -120,7 +120,7 @@ describe Note do
     #     it 'should return "r" + 3/2 duration enclosed inside \tuplet 3/2 {}' do
     #       [Rational(1,6),Rational(1,3),Rational(1,12)].each do |dur|
     #         n = Note.new(dur.to_r)
-    #         n.to_lilypond.should eq("\\tuplet 3/2 {r#{(1.5.to_r*dur).denominator}}")
+    #         expect(n.to_lilypond).to eq("\\tuplet 3/2 {r#{(1.5.to_r*dur).denominator}}")
     #       end
     #     end
     #   end
@@ -132,7 +132,7 @@ describe Note do
     #       [1,0.5,0.25,0.125,0.0625].each do |dur|
     #         [C3,Eb2,G4].each do |pitch|
     #           n = Note.new(dur.to_r, pitch)
-    #           n.to_lilypond.should eq(pitch.to_lilypond + n.duration.denominator.to_s)
+    #           expect(n.to_lilypond).to eq(pitch.to_lilypond + n.duration.denominator.to_s)
     #         end
     #       end
     #     end
@@ -143,7 +143,7 @@ describe Note do
     #       [1,0.25,0.0625].each do |dur|
     #         pitch_group = [Eb2,C3,G4]
     #         n = Note.new(dur.to_r, pitch_group)
-    #         n.to_lilypond.should eq("<" + pitch_group.map {|p| p.to_lilypond}.join(" ") + ">" + n.duration.denominator.to_s)
+    #         expect(n.to_lilypond).to eq("<" + pitch_group.map {|p| p.to_lilypond}.join(" ") + ">" + n.duration.denominator.to_s)
     #       end
     #     end
     #   end
@@ -155,7 +155,7 @@ describe Note do
     #       [0.75,0.375].each do |dur|
     #         [C3,Eb2,G4].each do |pitch|
     #           n = Note.new(dur.to_r, pitch)
-    #           n.to_lilypond.should eq(pitch.to_lilypond + (n.duration.denominator/2).to_s + ".")
+    #           expect(n.to_lilypond).to eq(pitch.to_lilypond + (n.duration.denominator/2).to_s + ".")
     #         end
     #       end
     #     end
@@ -166,7 +166,7 @@ describe Note do
     #       [0.75,0.375].each do |dur|
     #         pitch_group = [Eb2,C3,G4]
     #         n = Note.new(dur.to_r, pitch_group)
-    #         n.to_lilypond.should eq("<" + pitch_group.map {|p| p.to_lilypond}.join(" ") + ">" + (n.duration.denominator/2).to_s + ".")
+    #         expect(n.to_lilypond).to eq("<" + pitch_group.map {|p| p.to_lilypond}.join(" ") + ">" + (n.duration.denominator/2).to_s + ".")
     #       end
     #     end
     #   end
@@ -186,12 +186,12 @@ describe Note do
     #           n = Note.new(dur,pitch)
     #           str = n.to_lilypond
     #           strs = str.split
-    #           strs.size.should eq subdurs.size
+    #           expect(strs.size).to eq subdurs.size
     #           strs.each_with_index do |str,i|
     #             if i != (strs.size-1)
-    #               str.should eq(pitch.to_lilypond + subdurs[i].to_r.denominator.to_s + "~")
+    #               expect(str).to eq(pitch.to_lilypond + subdurs[i].to_r.denominator.to_s + "~")
     #             else
-    #               str.should eq(pitch.to_lilypond + subdurs[i].to_r.denominator.to_s)
+    #               expect(str).to eq(pitch.to_lilypond + subdurs[i].to_r.denominator.to_s)
     #             end
     #           end
     #         end

data/spec/printing/score_engraver_spec.rb

@@ -4,7 +4,7 @@ describe ScoreEngraver do
   describe '.part_titles' do
     context 'parts all have different lilypond settings' do
       it 'should return a map of part names to instrument names' do
-        parts = { 
+        parts = {
           :part1 => Part.new(Dynamics::MP, settings: [ LilypondSettings::ELECTRIC_PIANO ]),
           :part2 => Part.new(Dynamics::MP, settings: [ LilypondSettings::ELECTRIC_BASS ]),
           :part3 => Part.new(Dynamics::MP, settings: [ LilypondSettings::CLARINET ])
@@ -12,14 +12,14 @@ describe ScoreEngraver do
         titles = ScoreEngraver.figure_part_titles(parts)
 
         parts.each do |part_name, part|
-          titles[part_name].should eq(part.lilypond_settings.instrument_name)
+          expect(titles[part_name]).to eq(part.lilypond_settings.instrument_name)
         end
       end
     end
 
     context 'some parts have same lilypond settings' do
       it 'should return a map of part names to numbered instrument names' do
-        parts = { 
+        parts = {
           :part1 => Part.new(Dynamics::MP, settings: [ LilypondSettings::ELECTRIC_PIANO ]),
           :part2 => Part.new(Dynamics::MP, settings: [ LilypondSettings::ELECTRIC_PIANO ]),
           :part3 => Part.new(Dynamics::MP, settings: [ LilypondSettings::ELECTRIC_PIANO ])
@@ -29,11 +29,11 @@ describe ScoreEngraver do
         part_nums = []
         parts.each do |part_name, part|
           r = Regexp.new("#{part.lilypond_settings.instrument_name} (\\d)")
-          titles[part_name].should match r
+          expect(titles[part_name]).to match r
           m = titles[part_name].match(r)
           part_nums.push m.captures.first.to_s.to_i
         end
-        part_nums.sort.should eq((1..part_nums.size).to_a)
+        expect(part_nums.sort).to eq((1..part_nums.size).to_a)
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,4 +1,9 @@
 require 'rspec'
+
+# For code coverage
+require 'coveralls'
+Coveralls.wear!
+
 require 'musicality'
 
 include Musicality