musicality 0.11.1 → 0.12.0

data/spec/notation/model/link_spec.rb

@@ -13,53 +13,53 @@ require 'yaml'
 
     describe '#initialize' do
       it 'should assign the given pitch to :target_pitch' do
-        @obj.target_pitch.should eq(@tgt_pitch)
+        expect(@obj.target_pitch).to eq(@tgt_pitch)
       end
     end
-    
+
     describe '#==' do
       it 'should return true if two links have the same target pitch' do
-        @obj.should eq(klass.new(@tgt_pitch))
+        expect(@obj).to eq(klass.new(@tgt_pitch))
       end
-      
+
       it 'should return false if two links do not have the same target pitch' do
-        @obj.should_not eq(klass.new(@tgt_pitch.transpose(1)))
+        expect(@obj).to_not eq(klass.new(@tgt_pitch.transpose(1)))
       end
-      
+
       it 'should return false if the link type is different' do
-        @obj.should_not eq(klass2.new(@tgt_pitch))
+        expect(@obj).to_not eq(klass2.new(@tgt_pitch))
       end
     end
-    
+
     describe '#clone' do
       it 'should return a link equal to original' do
-        @obj.clone.should eq @obj
+        expect(@obj.clone).to eq @obj
       end
     end
-    
+
     describe '#to_yaml' do
       it 'should produce YAML that can be loaded' do
-        YAML.load(@obj.to_yaml).should eq @obj
+        expect(YAML.load(@obj.to_yaml)).to eq @obj
       end
     end
 
     describe '#pack' do
       it 'should produce a Hash' do
-        @obj.pack.should be_a Hash
+        expect(@obj.pack).to be_a Hash
       end
     end
 
     describe 'unpack' do
       it 'should produce a Link object equal the original' do
         obj2 = @obj.class.unpack @obj.pack
-        obj2.should be_a @obj.class
-        obj2.should eq @obj
+        expect(obj2).to be_a @obj.class
+        expect(obj2).to eq @obj
       end
     end
-    
+
     describe '#to_s' do
       it 'should produce string that include link char and target pitch str' do
-        @obj.to_s.should eq(link_symbol + @tgt_pitch.to_s)
+        expect(@obj.to_s).to eq(link_symbol + @tgt_pitch.to_s)
       end
     end
   end
@@ -72,43 +72,43 @@ describe Link::Tie do
 
   describe '#==' do
     it 'should return true if another Tie object is given' do
-      @obj.should eq(Link::Tie.new)
+      expect(@obj).to eq(Link::Tie.new)
     end
-    
+
     it 'should return false if an object of another class is given' do
-      @obj.should_not eq(5)
+      expect(@obj).to_not eq(5)
     end
   end
-  
+
   describe '#clone' do
     it 'should return a link equal to original' do
-      @obj.clone.should eq @obj
+      expect(@obj.clone).to eq @obj
     end
   end
-  
+
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
-      YAML.load(@obj.to_yaml).should eq @obj
+      expect(YAML.load(@obj.to_yaml)).to eq @obj
     end
   end
 
   describe '#pack' do
     it 'should produce a Hash' do
-      @obj.pack.should be_a Hash
+      expect(@obj.pack).to be_a Hash
     end
   end
 
   describe 'unpack' do
     it 'should produce a Link object equal the original' do
       obj2 = @obj.class.unpack @obj.pack
-      obj2.should be_a @obj.class
-      obj2.should eq @obj
+      expect(obj2).to be_a @obj.class
+      expect(obj2).to eq @obj
     end
   end
 
   describe '#to_s' do
     it "should return #{LINK_SYMBOLS[Link::Tie]}" do
-      @obj.to_s.should eq(LINK_SYMBOLS[Link::Tie])
+      expect(@obj.to_s).to eq(LINK_SYMBOLS[Link::Tie])
     end
   end
 end

data/spec/notation/model/meter_spec.rb

@@ -6,11 +6,11 @@ describe Meter do
     it 'should assign beats per measure and beat duration' do
       [[4,"1/4".to_r],[3,"1/4".to_r],[6,"1/8".to_r]].each do |bpm,bd|
         m = Meter.new(bpm,bd)
-        m.beats_per_measure.should eq bpm
-        m.beat_duration.should eq bd
-      end      
+        expect(m.beats_per_measure).to eq bpm
+        expect(m.beat_duration).to eq bd
+      end
     end
-    
+
     it 'should derive measure duration' do
       {
         [4,"1/4".to_r] => "1/1".to_r,
@@ -19,68 +19,68 @@ describe Meter do
         [12,"1/8".to_r] => "12/8".to_r,
       }.each do |bpm,bd|
         m = Meter.new(bpm,bd)
-        m.measure_duration.should eq(bpm*bd)
-      end      
+        expect(m.measure_duration).to eq(bpm*bd)
+      end
     end
   end
-  
+
   describe '#==' do
     context 'meters with same beat duration and beats per measure' do
       it 'should return true' do
         m1 = Meter.new(4,"1/4".to_r)
         m2 = Meter.new(4,"1/4".to_r)
-        m1.should eq m2
+        expect(m1).to eq m2
       end
     end
-    
+
     context 'meters with same meausre duration but different beat duration' do
       it 'should return false' do
         m1 = Meter.new(4,"1/4".to_r)
         m2 = Meter.new(2,"1/2".to_r)
-        m1.should_not eq m2
+        expect(m1).to_not eq m2
       end
     end
   end
-  
+
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
       m = Meter.new(4,"1/4".to_r)
-      YAML.load(m.to_yaml).should eq m
+      expect(YAML.load(m.to_yaml)).to eq m
     end
   end
 
   describe '#pack' do
     it 'should produce a Hash' do
-      FOUR_FOUR.pack.should be_a Hash
+      expect(FOUR_FOUR.pack).to be_a Hash
     end
   end
 
   describe 'unpack' do
     it 'should produce an object equal the original' do
       m2 = Meter.unpack FOUR_FOUR.pack
-      m2.should be_a Meter
-      m2.should eq(FOUR_FOUR)
+      expect(m2).to be_a Meter
+      expect(m2).to eq(FOUR_FOUR)
     end
   end
-  
+
   describe '#to_s' do
     context 'beat duration with 1 in denominator' do
       it 'should return string of fraction: beats_per_measure / beat_duration.denom' do
-        FOUR_FOUR.to_s.should eq("4/4")
-        TWO_FOUR.to_s.should eq("2/4")
-        THREE_FOUR.to_s.should eq("3/4")
-        TWO_TWO.to_s.should eq("2/2")
+        expect(FOUR_FOUR.to_s).to eq("4/4")
+        expect(TWO_FOUR.to_s).to eq("2/4")
+        expect(THREE_FOUR.to_s).to eq("3/4")
+        expect(TWO_TWO.to_s).to eq("2/2")
       end
     end
-    
+
     context 'beat duration with >1 in denominator' do
       it 'should return beats_per_measure * beat_dur fraction' do
-        SIX_EIGHT.to_s.should eq("2*3/8")
-        Meter.new(3,"3/8".to_r).to_s.should eq("3*3/8")
+        expect(SIX_EIGHT.to_s).to eq("2*3/8")
+        expect(Meter.new(3,"3/8".to_r).to_s).to eq("3*3/8")
       end
     end
   end
-  
+
   describe '#valid?' do
     {
       '4/4 meter' => [4,'1/4'.to_r],
@@ -91,11 +91,11 @@ describe Meter do
     }.each do |context_str,args|
       context context_str do
         it 'should return true' do
-          Meter.new(*args).should be_valid
+          expect(Meter.new(*args)).to be_valid
         end
       end
     end
-    
+
     {
       'non-integer positive beats per measure' => [4.0,"1/4".to_r],
       'integer negative beats per measure' => [-1,"1/4".to_r],
@@ -104,9 +104,9 @@ describe Meter do
     }.each do |context_str,args|
       context context_str do
         it 'should return false' do
-          Meter.new(*args).should be_invalid
+          expect(Meter.new(*args)).to be_invalid
         end
-      end      
+      end
     end
   end
 end

data/spec/notation/model/note_spec.rb

@@ -5,52 +5,52 @@ describe Note do
   before :all do
     @pitch = C4
   end
-  
-  describe '.new' do
+
+  describe '#initialize' do
     it 'should assign :duration that is given during construction' do
-      Note.new(2).duration.should eq(2)
+      expect(Note.new(2).duration).to eq(2)
     end
 
     it "should assign :articulation to NORMAL if not given" do
-      Note.new(2).articulation.should eq(NORMAL)
+      expect(Note.new(2).articulation).to eq(NORMAL)
     end
-    
+
     it "should assign :articulation parameter if given during construction" do
-      Note.new(2, articulation: STACCATO).articulation.should eq(STACCATO)
+      expect(Note.new(2, articulation: STACCATO).articulation).to eq(STACCATO)
     end
-    
+
     it 'should assign :marks to [] if not given' do
-      Note.new(2).marks.should eq([])
+      expect(Note.new(2).marks).to eq([])
     end
-    
+
     it 'should assign :marks if given' do
       [
         [], [BEGIN_SLUR], [END_SLUR]
       ].each do |marks|
-        Note.quarter(marks: marks).marks.should eq(marks)
+        expect(Note.quarter(marks: marks).marks).to eq(marks)
       end
     end
-    
+
     it 'should have no pitches if not given' do
-      Note.new(2).pitches.should be_empty
+      expect(Note.new(2).pitches).to be_empty
     end
-    
+
     it 'should assign pitches when given' do
       pitches = [ C2, D2 ]
       n = Note.new(2, pitches)
-      n.pitches.should include(pitches[0])
-      n.pitches.should include(pitches[1])
+      expect(n.pitches).to include(pitches[0])
+      expect(n.pitches).to include(pitches[1])
     end
   end
-  
+
   describe '#duration=' do
     it 'should assign duration' do
       note = Note.new 2, [@pitch]
       note.duration = 3
-      note.duration.should eq 3
+      expect(note.duration).to eq 3
     end
   end
-  
+
   {
     :sixteenth => Rational(1,16),
     :dotted_sixteenth => Rational(3,32),
@@ -64,11 +64,11 @@ describe Note do
   }.each do |fn_name,tgt_dur|
     describe ".#{fn_name}" do
       it "should make a note with duration #{tgt_dur}" do
-        Note.send(fn_name).duration.should eq tgt_dur
+        expect(Note.send(fn_name).duration).to eq tgt_dur
       end
     end
   end
-  
+
   describe '#transpose' do
     context 'given pitch diff' do
       before(:all) do
@@ -76,22 +76,22 @@ describe Note do
         @interval = 4
         @note2 = @note1.transpose(@interval)
       end
-        
+
       it 'should modifiy pitches by adding pitch diff' do
         @note2.pitches.each_with_index do |p,i|
-          p.diff(@note1.pitches[i]).should eq(@interval)
+          expect(p.diff(@note1.pitches[i])).to eq(@interval)
         end
       end
-        
+
       it 'should also affect link targets' do
         @note1.links.each do |k,v|
           kt = k.transpose(@interval)
-          @note2.links.should have_key kt
-          @note2.links[kt].target_pitch.should eq(v.target_pitch.transpose(@interval))
+          expect(@note2.links).to have_key kt
+          expect(@note2.links[kt].target_pitch).to eq(v.target_pitch.transpose(@interval))
         end
       end
     end
-    
+
     context 'with links that have no target pitch' do
       it 'should not raise error' do
         n = Note::half([E2],links: {E2 => Link::Tie.new})
@@ -99,20 +99,41 @@ describe Note do
       end
     end
   end
-  
+
   describe '#resize' do
     it 'should return new note object with given duration' do
       note = Note::quarter.resize("1/2".to_r)
-      note.duration.should eq(Rational(1,2))
+      expect(note.duration).to eq(Rational(1,2))
+    end
+  end
+
+  describe '#tie_to' do
+    context 'given a pitch object' do
+      it 'should return new note object tied to given pitch' do
+        note = Note.half(@pitch).tie_to(@pitch)
+        expect(note.links).to have_key(@pitch)
+        expect(note.links[@pitch]).to be_a Link::Tie
+      end
+    end
+
+    context 'given an array of pitch objects' do
+      it 'should return new note object tied to given pitches' do
+        pitches = [@pitch,@pitch+1]
+        note = Note.half(pitches).tie_to(pitches)
+        pitches.each do |pitch|
+          expect(note.links).to have_key(pitch)
+          expect(note.links[pitch]).to be_a Link::Tie
+        end
+      end
     end
   end
-  
+
   describe '#to_s' do
     before :all do
       @note_parser = Parsing::NoteParser.new
     end
-    
-    context 
+
+    context
     it 'should produce string that when parsed produces an equal note' do
       durations = ["1/8".to_r,"1".to_r,"5/3".to_r]
       include Articulations
@@ -124,7 +145,7 @@ describe Note do
         [[C5,E6,Gb2],{ C5 => Link::Glissando.new(D5) }],
         [[C5,E6,Gb2],{ C5 => Link::Portamento.new(D5), Gb2 => Link::Tie.new }],
       ]
-      
+
       notes = []
       durations.each do |d|
         pitches_links_sets.each do |pitches_links_set|
@@ -140,36 +161,36 @@ describe Note do
           end
         end
       end
-      
+
       notes.each do |note|
         str = note.to_s
         res = @note_parser.parse(str)
         note2 = res.to_note
-        note2.should eq(note)
+        expect(note2).to eq(note)
       end
     end
   end
-  
+
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
       n = Note.new(1,[C2])
-      YAML.load(n.to_yaml).should eq n
-      
+      expect(YAML.load(n.to_yaml)).to eq n
+
       n = Note.new(1,[C2,E2])
-      YAML.load(n.to_yaml).should eq n
-      
+      expect(YAML.load(n.to_yaml)).to eq n
+
       n = Note.new(1,[C2], articulation: STACCATO)
-      YAML.load(n.to_yaml).should eq n
-      
+      expect(YAML.load(n.to_yaml)).to eq n
+
       n = Note.new(1,[E2], links: {E2 => Link::Portamento.new(F2)})
-      YAML.load(n.to_yaml).should eq n
+      expect(YAML.load(n.to_yaml)).to eq n
     end
   end
 
   describe '#pack' do
     it 'should produce a Hash' do
       n = Note.quarter([E2,F2,A2], articulation: STACCATO, marks: [BEGIN_SLUR], links: {E2 => Link::Tie.new, F2 => Link::Glissando.new(C3)})
-      n.pack.should be_a Hash
+      expect(n.pack).to be_a Hash
     end
   end
 
@@ -177,15 +198,15 @@ describe Note do
     it 'should produce an object equal the original' do
       n = Note.quarter([E2,F2,A2], articulation: STACCATO, marks: [BEGIN_SLUR], links: {E2 => Link::Tie.new, F2 => Link::Glissando.new(C3)})
       n2 = Note.unpack n.pack
-      n2.should be_a Note
-      n2.should eq n
+      expect(n2).to be_a Note
+      expect(n2).to eq n
     end
   end
-  
+
   describe '#valid?' do
     context 'note with positive duration' do
       it 'should return true' do
-        Note.new(1,[C2]).should be_valid
+        expect(Note.new(1,[C2])).to be_valid
       end
     end
   end

data/spec/notation/model/part_spec.rb

@@ -5,29 +5,29 @@ describe Part do
   describe '#initialize' do
     it 'should use empty containers for parameters not given' do
       p = Part.new(Dynamics::MP)
-      p.notes.should be_empty
-      p.dynamic_changes.should be_empty
+      expect(p.notes).to be_empty
+      expect(p.dynamic_changes).to be_empty
     end
-    
+
     it "should assign parameters given during construction" do
       p = Part.new(Dynamics::PPP)
-      p.start_dynamic.should eq Dynamics::PPP
-      
+      expect(p.start_dynamic).to eq Dynamics::PPP
+
       notes = [Note::whole([A2]), Note::half]
       dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.sigmoid(Dynamics::MF,1) }
       p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs)
-      p.notes.should eq notes
-      p.dynamic_changes.should eq dcs
+      expect(p.notes).to eq notes
+      expect(p.dynamic_changes).to eq dcs
 
       p = Part.new(Dynamics::P, settings: [ "dummy" ])
-      p.settings.should eq [ "dummy" ]
+      expect(p.settings).to eq [ "dummy" ]
     end
   end
 
   describe '#find_settings' do
     context 'settings is empty' do
       it 'should return nil' do
-        Part.new(Dynamics::P).find_settings(Integer).should be_nil
+        expect(Part.new(Dynamics::P).find_settings(Integer)).to be_nil
       end
     end
 
@@ -38,14 +38,14 @@ describe Part do
 
       context 'given class of object in settings' do
         it 'should return the object' do
-          @part.find_settings(Integer).should be_a Integer
-          @part.find_settings(String).should be_a String
+          expect(@part.find_settings(Integer)).to be_a Integer
+          expect(@part.find_settings(String)).to be_a String
         end
       end
 
       context 'given class not of any object in settings' do
         it 'should return nil' do
-          @part.find_settings(Float).should be_nil
+          expect(@part.find_settings(Float)).to be_nil
         end
       end
     end
@@ -54,7 +54,7 @@ describe Part do
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
       p = Samples::SAMPLE_PART
-      YAML.load(p.to_yaml).should eq p
+      expect(YAML.load(p.to_yaml)).to eq p
     end
   end
 
@@ -63,7 +63,7 @@ describe Part do
       notes = [Note::whole([A2]), Note::half]
       dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.sigmoid(Dynamics::MF,1) }
       p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs, settings: [ "dummy" ])
-      p.pack.should be_a Hash
+      expect(p.pack).to be_a Hash
     end
   end
 
@@ -73,8 +73,8 @@ describe Part do
       dcs = { "1/2".to_r => Change::Immediate.new(Dynamics::P), 1 => Change::Gradual.sigmoid(Dynamics::MF,1) }
       p = Part.new(Dynamics::FF, notes: notes, dynamic_changes: dcs, settings: [ "dummy" ])
       p2 = Part.unpack p.pack
-      p2.should be_a Part
-      p2.should eq p
+      expect(p2).to be_a Part
+      expect(p2).to eq p
     end
   end
 
@@ -93,11 +93,11 @@ describe Part do
     }.each do |context_str, args|
       context context_str do
         it 'should return false' do
-          Part.new(*args).should be_invalid
+          expect(Part.new(*args)).to be_invalid
         end
       end
     end
-    
+
     {
       'valid notes' => [ Dynamics::PP,
         :notes => [ Note::whole, quarter([C5]) ]],
@@ -110,7 +110,7 @@ describe Part do
       context context_str do
         it 'should return true' do
           part = Part.new(*args)
-          part.should be_valid
+          expect(part).to be_valid
         end
       end
     end