musicality 0.11.1 → 0.12.0

data/spec/notation/model/pitch_spec.rb

@@ -4,7 +4,7 @@ require 'yaml'
 describe Pitch do
 
   before :each do
-    @cases = 
+    @cases =
     [
       { :octave => 1, :semitone => 0, :cent => 0, :ratio => 2.0, :total_cents => 1200 },
       { :octave => 2, :semitone => 0, :cent => 0, :ratio => 4.0, :total_cents => 2400 },
@@ -21,32 +21,32 @@ describe Pitch do
       { :octave => -5, :semitone => -2, :cent => -77, :ratio => 0.02663, :total_cents => -6277 }
     ]
   end
-  
+
   it "should be constructable with no parameters (no error raised)" do
-    lambda { Pitch.new }.should_not raise_error
+    expect(lambda { Pitch.new }).to_not raise_error
   end
-  
+
   it "should take keyword args" do
     obj = Pitch.new octave: 4, semitone: 3, cent: 5
-    obj.octave.should eq(4)
-    obj.semitone.should eq(3)
-    obj.cent.should eq(5)
+    expect(obj.octave).to eq(4)
+    expect(obj.semitone).to eq(3)
+    expect(obj.cent).to eq(5)
   end
-  
+
   it "should use default octave, semitone, and cent if none is given" do
     p = Pitch.new
-    p.ratio.should be_within(0.01).of(1.0)
-    p.total_cents.should eq(0)
+    expect(p.ratio).to be_within(0.01).of(1.0)
+    expect(p.total_cents).to eq(0)
   end
-  
+
   it "should use the octave and semitone given during construction" do
     @cases.each do |case_data|
       p = Pitch.new octave: case_data[:octave], semitone: case_data[:semitone], cent: case_data[:cent]
-      p.ratio.should be_within(0.01).of case_data[:ratio]
-      p.total_cents.should be case_data[:total_cents]
+      expect(p.ratio).to be_within(0.01).of case_data[:ratio]
+      expect(p.total_cents).to be case_data[:total_cents]
     end
   end
-  
+
   describe '#diff' do
     it 'should return the difference between the given pitch, in semitones' do
       [
@@ -57,28 +57,28 @@ describe Pitch do
 	[A5,Pitch.new(octave:5, semitone: 5, cent: 22),378/100.0],
 	[A5,Pitch.new(octave:5, semitone: 11, cent: 85),-285/100.0],
       ].each do |a,b,c|
-	a.diff(b).should eq(c)
+         expect(a.diff(b)).to eq(c)
       end
     end
   end
-  
+
   describe '#transpose' do
     it 'should make a new pitch, adding the given interval to total semitones' do
       [0,1,2,5,12,13,-1,-2,-5,-12,-13].each do |interval|
         pitch = Eb3.transpose(interval)
-        pitch.should_not be Eb3
-        pitch.diff(Eb3).should eq(interval)
+        expect(pitch).to_not be Eb3
+        expect(pitch.diff(Eb3)).to eq(interval)
       end
     end
   end
-  
+
   describe '#+' do
     it 'should produce same result as #transpose' do
       [0,1,2,5,12,13,-1,-2,-5,-12,-13].each do |interval|
         pitch = Eb3 + interval
-        pitch.should_not be Eb3
+        expect(pitch).to_not be Eb3
         pitch2 = Eb3.transpose(interval)
-        pitch.should eq(pitch2)
+        expect(pitch).to eq(pitch2)
       end
     end
   end
@@ -87,37 +87,37 @@ describe Pitch do
     it 'should produce same result as #transpose, with negative interval' do
       [0,1,2,5,12,13,-1,-2,-5,-12,-13].each do |interval|
         pitch = Eb3 - interval
-        pitch.should_not be Eb3
+        expect(pitch).to_not be Eb3
         pitch2 = Eb3.transpose(-interval)
-        pitch.should eq(pitch2)
+        expect(pitch).to eq(pitch2)
       end
     end
   end
 
   describe '.total_semitones' do
     it 'should convert to whole/fractional total semitones value' do
-      C4.total_semitones.should eq(48)
-      C5.total_semitones.should eq(60)
-      C4.transpose(0.1).total_semitones.should eq(48.1)
-      C5.transpose(0.19).total_semitones.should eq(60.19)
-      C5.transpose(-0.19).total_semitones.should eq(59.81)
+      expect(C4.total_semitones).to eq(48)
+      expect(C5.total_semitones).to eq(60)
+      expect(C4.transpose(0.1).total_semitones).to eq(48.1)
+      expect(C5.transpose(0.19).total_semitones).to eq(60.19)
+      expect(C5.transpose(-0.19).total_semitones).to eq(59.81)
     end
   end
-  
+
   describe '.from_semitones' do
     it 'should convert (rounded) fractional part to cent value' do
-      Pitch.from_semitones(4).total_cents.should eq(400)
-      Pitch.from_semitones(4.11).total_cents.should eq(411)
-      Pitch.from_semitones(57.123).total_cents.should eq(5712)
-      Pitch.from_semitones(57.125).total_cents.should eq(5713)
+      expect(Pitch.from_semitones(4).total_cents).to eq(400)
+      expect(Pitch.from_semitones(4.11).total_cents).to eq(411)
+      expect(Pitch.from_semitones(57.123).total_cents).to eq(5712)
+      expect(Pitch.from_semitones(57.125).total_cents).to eq(5713)
     end
   end
-  
+
   describe '.from_ratio' do
     it 'should return a Pitch with given ratio' do
       @cases.each do |case_data|
         p = Pitch.from_ratio case_data[:ratio]
-        p.total_cents.should eq case_data[:total_cents]
+        expect(p.total_cents).to eq case_data[:total_cents]
       end
     end
   end
@@ -125,93 +125,94 @@ describe Pitch do
   describe '.from_freq' do
     it 'should make a pitch whose freq is approximately the given freq' do
       [16.35, 440.0, 987.77].each do |given_freq|
-	pitch = Pitch.from_freq given_freq
-	pitch.freq.should be_within(0.01).of(given_freq)
+        pitch = Pitch.from_freq given_freq
+        expect(pitch.freq).to be_within(0.01).of(given_freq)
       end
     end
   end
-  
+
   it "should be comparable to other pitches" do
     p1 = Pitch.new semitone: 1
     p2 = Pitch.new semitone: 2
     p3 = Pitch.new semitone: 3
 
-    p1.should eq(Pitch.new semitone: 1)
-    p2.should eq(Pitch.new semitone: 2)
-    p3.should eq(Pitch.new semitone: 3)
-    
-    p1.should be < p2
-    p1.should be < p3
-    p2.should be < p3
-    p3.should be > p2
-    p3.should be > p1
-    p2.should be > p1
-  end
-  
+    expect(p1).to eq(Pitch.new semitone: 1)
+    expect(p2).to eq(Pitch.new semitone: 2)
+    expect(p3).to eq(Pitch.new semitone: 3)
+
+    expect(p1).to be < p2
+    expect(p1).to be < p3
+    expect(p2).to be < p3
+    expect(p3).to be > p2
+    expect(p3).to be > p1
+    expect(p2).to be > p1
+  end
+
   it "should have freq of 440 for A4" do
     a4 = Pitch.new octave: 4, semitone: 9
-    a4.freq.should be_within(0.01).of(440.0)
+    expect(a4.freq).to be_within(0.01).of(440.0)
   end
-  
+
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
       p = Pitch.new(octave: 1, semitone: 2)
-      YAML.load(p.to_yaml).should eq p
+      expect(YAML.load(p.to_yaml)).to eq p
     end
   end
 
   describe '#pack' do
     it 'should produce a Hash' do
-      Bb3.pack.should be_a Hash
+      expect(Bb3.pack).to be_a Hash
     end
   end
 
   describe 'unpack' do
     it 'should produce an object equal the original' do
       p2 = Pitch.unpack Bb3.pack
-      p2.should be_a Pitch
-      p2.should eq Bb3
+      expect(p2).to be_a Pitch
+      expect(p2).to eq Bb3
     end
   end
-  
+
   describe '#to_s' do
     context 'on-letter semitones' do
       it 'should return the semitone letter + octave number' do
         { C0 => "C0", D1 => "D1", E7 => "E7",
           F8 => "F8", G3 => "G3", A4 => "A4",
           B5 => "B5", C2 => "C2" }.each do |p,s|
-          p.to_s.should eq s
+          expect(p.to_s).to eq s
         end
       end
     end
-    
+
     context 'off-letter semitones' do
       context 'sharpit set false' do
         it 'should return semitone letter + "b" + octave number' do
           { Db0 => "Db0", Eb1 => "Eb1", Gb7 => "Gb7",
             Ab4 => "Ab4", Bb1 => "Bb1" }.each do |p,s|
-            p.to_s(false).should eq s
+            expect(p.to_s(false)).to eq s
           end
         end
       end
-      
+
       context 'sharpit set true' do
         it 'should return semitone letter + "#" + octave number' do
           { Db0 => "C#0", Eb1 => "D#1", Gb7 => "F#7",
             Ab4 => "G#4", Bb1 => "A#1" }.each do |p,s|
-            p.to_s(true).should eq s
+            expect(p.to_s(true)).to eq s
           end
         end
       end
     end
-    
+
     context 'non-zero cent value' do
       it 'should append +n (n = cent value)' do
-	{ C0.transpose(0.01) => "C0+1", E1.transpose(0.15) => "E1+15",
-	  G5.transpose(-0.55) => "Gb5+45"
-	}.each do |p,s|
-	  p.to_s.should eq s
-	end
+      	{
+          C0.transpose(0.01) => "C0+1", E1.transpose(0.15) => "E1+15",
+      	  G5.transpose(-0.55) => "Gb5+45"
+      	}.each do |p,s|
+      	  expect(p.to_s).to eq s
+      	end
       end
     end
   end

data/spec/notation/model/score_spec.rb

@@ -4,7 +4,7 @@ describe Score do
   describe '#title' do
     context 'given no arg' do
       it 'should return the title' do
-        Score.new(:title => "MyTitle").title.should eq("MyTitle")
+        expect(Score.new(:title => "MyTitle").title).to eq("MyTitle")
       end
     end
 
@@ -12,7 +12,7 @@ describe Score do
       it 'should assign the given value to title' do
         score = Score.new(:title => "MyTitle")
         score.title("A Better Title")
-        score.title.should eq("A Better Title")
+        expect(score.title).to eq("A Better Title")
       end
     end
   end
@@ -20,7 +20,7 @@ describe Score do
   describe '#composer' do
     context 'given no arg' do
       it 'should return the composer' do
-        Score.new(:composer => "Beethoven").composer.should eq("Beethoven")
+        expect(Score.new(:composer => "Beethoven").composer).to eq("Beethoven")
       end
     end
 
@@ -28,7 +28,7 @@ describe Score do
       it 'should assign the given value to composer' do
         score = Score.new(:composer => "Beethoven")
         score.composer("Mozart")
-        score.composer.should eq("Mozart")
+        expect(score.composer).to eq("Mozart")
       end
     end
   end
@@ -37,14 +37,14 @@ describe Score do
     context 'has program with more than one segment' do
       it 'should return false' do
         score = Score.new(program: [0..2,0..2])
-        score.collated?.should be false
+        expect(score.collated?).to be false
       end
     end
 
     context 'has program with 0 segments' do
       it 'should return false' do
         score = Score.new(program: [])
-        score.collated?.should be false
+        expect(score.collated?).to be false
       end
     end
 
@@ -55,7 +55,7 @@ describe Score do
             score = Score.new(program: [0..2],
               parts: { "dummy" => Part.new(Dynamics::MP, notes: [Note.whole]*2)}
             )
-            score.collated?.should be true
+            expect(score.collated?).to be true
           end
         end
 
@@ -64,9 +64,9 @@ describe Score do
             score = Score.new(program: [0..1],
               parts: { "dummy" => Part.new(Dynamics::MP, notes: [Note.whole]*2) }
             )
-            score.collated?.should be false
+            expect(score.collated?).to be false
             score.program = [0..3]
-            score.collated?.should be false
+            expect(score.collated?).to be false
           end
         end
       end
@@ -74,7 +74,7 @@ describe Score do
       context 'program segment does not start at 0' do
         it 'should return false' do
           score = Score.new(program: [1..2])
-          score.collated?.should be false
+          expect(score.collated?).to be false
         end
       end
     end
@@ -83,25 +83,25 @@ describe Score do
   describe '#valid?' do
     context 'non-Range objects' do
       it 'should return false' do
-        Score.new(program: [1,2,3]).should_not be_valid
+        expect(Score.new(program: [1,2,3])).to_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
+        expect(Score.new(program: [0..2,1..2,0..4])).to 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
+        expect(Score.new(program: [2..0,2..1,04..0])).to be_invalid
       end
     end
 
     context 'increasing, negative segments' do
       it 'should return false' do
-        Score.new(program: [-1..2,-2..0,-2..2]).should be_invalid
+        expect(Score.new(program: [-1..2,-2..0,-2..2])).to be_invalid
       end
     end
   end
@@ -126,15 +126,15 @@ describe Score::Tempo do
   describe '#initialize' do
     it 'should use empty containers for parameters not given' do
       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
+      expect(s.parts).to be_empty
+      expect(s.program).to be_empty
+      expect(s.tempo_changes).to be_empty
+      expect(s.meter_changes).to be_empty
     end
 
     it 'should assign given parameters' do
       s = Score::Tempo.new(120)
-      s.start_tempo.should eq 120
+      expect(s.start_tempo).to eq 120
 
       m = FOUR_FOUR
       parts = { "piano (LH)" => Samples::SAMPLE_PART }
@@ -149,34 +149,36 @@ describe Score::Tempo do
         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
+      expect(s.start_meter).to eq m
+      expect(s.parts).to eq parts
+      expect(s.program).to eq program
+      expect(s.meter_changes).to eq mcs
+      expect(s.tempo_changes).to eq tcs
     end
   end
 
   describe '#duration' do
     context 'with no parts' do
       it 'should return 0' do
-        Score::Tempo.new(120).duration.should eq(0)
+        expect(Score::Tempo.new(120).duration).to eq(0)
       end
     end
     context 'with one part' do
       it 'should return the duration of the part, in notes' do
-        Score::Tempo.new(120, parts: {
+        s = Score::Tempo.new(120, parts: {
           "abc" => Part.new(Dynamics::MF, notes: "/4 /4 /2 3/4".to_notes)
-        }).duration.should eq(1.75)
+        })
+        expect(s.duration).to 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(120, parts: {
+        s = 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)
+        })
+        expect(s.duration).to eq(2)
       end
     end
   end
@@ -194,7 +196,7 @@ describe Score::Tempo do
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
-          Score::Tempo.new(*args).should be_valid
+          expect(Score::Tempo.new(*args)).to be_valid
         end
       end
     end
@@ -215,7 +217,7 @@ describe Score::Tempo do
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do
-          Score::Tempo.new(*args).should be_invalid
+          expect(Score::Tempo.new(*args)).to be_invalid
         end
       end
     end
@@ -223,25 +225,25 @@ describe Score::Tempo do
 
   describe '#pack' do
     it 'should produce a Hash' do
-      @basic_score.pack.should be_a Hash
+      expect(@basic_score.pack).to be_a Hash
     end
 
     it 'should pack program as an array of strings' do
       program = @basic_score.pack[:program]
-      program.each {|entry| entry.should be_a String}
+      program.each {|entry| expect(entry).to be_a String}
     end
 
     it 'should pack sections as a Hash of strings' do
       program = @basic_score.pack[:sections]
-      program.each {|name,entry| entry.should be_a String}
+      program.each {|name,entry| expect(entry).to be_a String}
     end
   end
 
   describe 'unpack' do
     it 'should produce an object equal the original' do
       score2 = Score::Tempo.unpack @basic_score.pack
-      score2.should be_a Score
-      score2.should eq @basic_score
+      expect(score2).to be_a Score
+      expect(score2).to eq @basic_score
     end
   end
 end
@@ -250,8 +252,8 @@ describe Score::Timed do
   describe '#initialize' do
     it 'should use empty containers for parameters not given' do
       s = Score::Timed.new
-      s.parts.should be_empty
-      s.program.should be_empty
+      expect(s.parts).to be_empty
+      expect(s.program).to be_empty
     end
 
     it 'should assign given parameters' do
@@ -259,17 +261,18 @@ describe Score::Timed do
       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
+      expect(s.parts).to eq parts
+      expect(s.program).to eq program
     end
   end
 
   describe '#duration' do
     it 'should return the duration of the longest part' do
-      Score::Timed.new(parts: {
+      s = Score::Timed.new(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)
+      })
+      expect(s.duration).to eq(2)
     end
   end
 
@@ -280,7 +283,7 @@ describe Score::Timed do
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
-          Score::Timed.new(*args).should be_valid
+          expect(Score::Timed.new(*args)).to be_valid
         end
       end
     end
@@ -291,7 +294,7 @@ describe Score::Timed do
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do
-          Score::Timed.new(*args).should be_invalid
+          expect(Score::Timed.new(*args)).to be_invalid
         end
       end
     end
@@ -303,7 +306,7 @@ describe Score::Timed do
         "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)
       })
-      score.pack.should be_a Hash
+      expect(score.pack).to be_a Hash
     end
   end
 
@@ -314,8 +317,8 @@ describe Score::Timed do
         "def" => Part.new(Dynamics::MF, notes: "/4 /4 /2 1".to_notes)
       })
       score2 = Score::Timed.unpack score.pack
-      score2.should be_a score.class
-      score2.should eq score
+      expect(score2).to be_a score.class
+      expect(score2).to eq score
     end
   end
 end

data/spec/notation/parsing/articulation_parsing_spec.rb

@@ -2,15 +2,15 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Parsing::ArticulationParser do
   parser = Parsing::ArticulationParser.new
-  
+
   ARTICULATION_SYMBOLS.each do |art,str|
     res = parser.parse(str)
     it "should parse '#{str}'" do
-      res.should_not be nil
+      expect(res).to_not be nil
     end
-    
+
     it 'should return a node to responds to :to_articulation correctly' do
-      res.to_articulation.should eq art
+      expect(res.to_articulation).to eq art
     end
   end
 end