musicality 0.8.0 → 0.9.0

data/spec/notation/packing/part_packing_spec.rb

@@ -1,66 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Part do
-  before :all do
-    @p = Part.new(
-      Dynamics::MP,
-      notes: Note.split_parse("/4Bb2 /8 /8F3= /2F3 /4Bb2 /8 /8F3= /2F3"),
-      dynamic_changes: {
-        1 => Change::Immediate.new(Dynamics::PP),
-        2 => Change::Gradual.linear(Dynamics::FF, 2.0)
-      }
-    )
-    
-    @h = @p.pack
-  end
-
-  describe '#pack' do
-    it 'should produce a hash' do
-      @h.should be_a Hash
-    end
-    
-    it 'should return a hash with keys: "notes", "start_dynamic", and "dynamic_changes"' do
-      @h.keys.should include("notes")
-      @h.keys.should include("start_dynamic")
-      @h.keys.should include("dynamic_changes")
-    end
-    
-    it 'should pack notes into a string' do
-      @h['notes'].should be_a String
-    end
-    
-    it 'should pack start dynamic as plain numeric value' do
-      @h['start_dynamic'].should be_a Numeric
-    end
-    
-    it 'should pack dynamic changes as whatver type Change#pack returns' do
-      @h['dynamic_changes'].each do |offset,packed_v|
-        change_v = @p.dynamic_changes[offset]
-        t = change_v.pack.class
-        packed_v.should be_a t
-      end
-    end
-  end
-  
-  describe '.unpack' do
-    before :all do
-      @p2 = Part.unpack @h
-    end
-    
-    it 'should return a Part' do
-      @p2.should be_a Part
-    end
-    
-    it 'should successfuly unpack the notes' do
-      @p2.notes.should eq @p.notes
-    end
-    
-    it 'should successfuly unpack the start dynamic' do
-      @p2.start_dynamic.should eq @p.start_dynamic
-    end
-    
-    it 'should successfuly unpack the dynamic changes' do
-      @p2.dynamic_changes.should eq @p.dynamic_changes
-    end
-  end
-end

data/spec/notation/packing/score_packing_spec.rb

@@ -1,255 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-measured_score = Score::Measured.new(FOUR_FOUR,120) do |s|
-  s.title "The best song ever"
-  s.composer "James T."
-
-  s.meter_changes[1] = Change::Immediate.new(THREE_FOUR)
-  s.meter_changes[7] = Change::Immediate.new(SIX_EIGHT)
-  
-  s.tempo_changes[2] = Change::Immediate.new(100)
-  s.tempo_changes[4] = Change::Gradual.linear(70,2)
-  s.tempo_changes[9] = Change::Gradual.sigmoid(99,5).trim(2,2)
-  
-  s.program += [0...2, 0...2,2...4,0...2]
-  s.parts["lead"] = Part.new(Dynamics::MF) do |p|
-    riff = "/6Bb3 /4 /12Db4= /6Db4= /36Db4 /36Eb4 /36Db4 /6Ab3 /12Db4 \
-            /6Bb3 /4 /12Db4= /4Db4=                      /8Db4= /8C4".to_notes
-    p.notes = riff + riff.map {|n| n.transpose(2) }
-    p.dynamic_changes[1] = Change::Gradual.linear(Dynamics::F,2)
-  end
-  
-  s.parts["bass"] = Part.new(Dynamics::MP) do |p|
-    riff = "/6Bb2 /4 /3Ab2 /6F2 /12Ab2 \
-            /6Bb2 /4 /3Ab2 /4Ab2".to_notes
-    p.notes = riff + riff.map {|n| n.transpose(2) }
-    p.dynamic_changes[1] = Change::Immediate.new(Dynamics::F)
-    p.dynamic_changes[3] = Change::Gradual.sigmoid(Dynamics::PP,4).trim(1,1)
-  end
-end
-
-unmeasured_score = Score::Unmeasured.new(30) do |s|
-  s.program = measured_score.program
-  s.parts = measured_score.parts
-  s.title measured_score.title
-  s.composer measured_score.composer
-end
-
-timed_score = Score::Timed.new do |s|
-  s.program = measured_score.program
-  s.parts = measured_score.parts
-  s.title measured_score.title
-  s.composer measured_score.composer
-end
-
-[ measured_score, unmeasured_score, timed_score ].each do |score|
-  describe score.class do
-    before :all do
-      @score = score
-      @h = @score.pack
-    end
-    
-    describe '#pack' do
-      it 'should return a hash' do
-        @h.should be_a Hash
-      end
-      
-      it 'should return a hash with keys: "type","parts", and "program"' do
-        ["type","parts","program"].each do |key|
-          @h.should have_key(key)
-        end
-      end
-      
-      it 'should pack program as an array with same size' do
-        @h['program'].should be_a Array
-        @h['program'].size.should eq(@score.program.size)
-      end
-      
-      it 'should pack program segments as strings' do
-        @h['program'].each {|x| x.should be_a String }
-      end
-  
-      it 'should pack parts as hash' do
-        @h['parts'].should be_a Hash
-      end
-      
-      it 'should pack parts as whatever Part#pack returns' do
-        @score.parts.each do |name,part|
-          packing = part.pack
-          @h['parts'][name].should eq packing
-        end
-      end
-
-      it 'should add title to packing' do
-        @h.should have_key "title"
-        @h["title"].should eq @score.title
-      end
-
-      it 'should add composer to packing' do
-        @h.should have_key "composer"
-        @h["composer"].should eq @score.composer
-      end
-    end
-    
-    describe '.unpack' do
-      before :all do
-        @score2 = score.class.unpack @h
-      end
-      
-      it "should return a #{score.class}" do
-        @score2.should be_a score.class
-      end
-      
-      it 'should successfuly unpack the parts' do
-        @score2.parts.should eq @score.parts
-      end
-      
-      it 'should successfuly unpack the program' do
-        @score2.program.should eq @score.program
-      end
-
-      it 'should successfuly unpack the title' do
-        @score2.title.should eq @score.title
-      end
-
-      it 'should successfuly unpack the composer' do
-        @score2.composer.should eq @score.composer
-      end
-    end
-  end
-end
-
-[ measured_score, unmeasured_score ].each do |score|
-  describe score.class do
-    before :all do
-      @score = score
-      @h = @score.pack
-    end
-    
-    describe '#pack' do
-      it 'should return a hash with keys: "start_tempo" and "tempo_changes"' do
-        ["start_tempo","tempo_changes"].each {|key| @h.should have_key(key) }
-      end
-
-      it 'should pack start tempo as numeric' do
-        @h['start_tempo'].should be_a Numeric
-      end
-
-      it 'should pack tempo changes as a hash' do
-        @h['tempo_changes'].should be_a Hash
-      end
-      
-      it 'should pack tempo changes values using Change#pack' do
-        @h['tempo_changes'].each do |offset,packed_v|
-          change = @score.tempo_changes[offset]
-          packed_v.should eq(change.pack)
-        end
-      end
-    end
-    
-    describe '.unpack' do
-      before :all do
-        @score2 = score.class.unpack @h
-      end
-      
-      it 'should successfuly unpack the start tempo' do
-        @score2.start_tempo.should eq @score.start_tempo
-      end
-      
-      it 'should successfuly unpack the tempo changes' do
-        @score2.tempo_changes.should eq @score.tempo_changes
-      end
-    end
-  end
-end
-
-describe Score::Measured do
-  before :all do
-    @score = measured_score
-    @h = @score.pack
-  end
-  
-  describe '#pack' do    
-    it 'should return a hash with keys: "start_meter" and "meter_changes"' do
-      ["start_meter","meter_changes"].each { |key| @h.should have_key(key) }
-    end
-    
-    it 'should set "type" key to "Measured"' do
-      @h["type"].should eq("Measured")
-    end
-    
-    it 'should pack start meter as a string' do
-      @h['start_meter'].should be_a String
-    end
-
-    it 'should pack meter changes values using Change#pack(:with => :to_s)' do
-      @h['meter_changes'].each do |offset,packed_v|
-        change = @score.meter_changes[offset]
-        packed_v.should eq(change.pack(:with => :to_s))
-      end
-    end
-
-    it 'should pack meter change end values as strings' do
-      @h['meter_changes'].each do |offset,packed_v|
-        packed_v["end_value"].should be_a String
-      end
-    end    
-  end
-  
-  describe '.unpack' do
-    before :all do
-      @score2 = Score::Measured.unpack @h
-    end
-    
-    it 'should successfuly unpack the start meter' do
-      @score2.start_meter.should eq @score.start_meter
-    end
-
-    it 'should successfuly unpack the meter changes' do
-      @score2.meter_changes.should eq @score.meter_changes
-    end
-  end
-end
-
-describe Score::Unmeasured do
-  describe '#pack' do
-    it 'should set "type" key to "Unmeasured"' do
-      unmeasured_score.pack["type"].should eq("Unmeasured")
-    end    
-  end
-end
-
-describe Score::Timed do
-  before :all do
-    @score = timed_score
-    @h = @score.pack
-  end
-  
-  describe '#pack' do
-    it 'should set "type" key to "Timed"' do
-      @h["type"].should eq("Timed")
-    end    
-  end
-end
-
-describe Score do
-  describe '.unpack' do
-    [ timed_score, unmeasured_score, measured_score ].each do |score|
-      context "given packing from a #{score.class} object" do
-        before :all do
-          @packing = score.pack
-          @score2 = Score.unpack(@packing)
-        end
-        
-        it "should return a #{score.class} object equal to original" do
-          @score2.should be_a score.class
-          @score2.should eq(score)
-        end
-        
-        it "should return a score equal to what #{score.class}.unpack returns" do
-          @score2.should eq(score.class.unpack(@packing))
-        end
-      end
-    end
-  end
-end

data/spec/performance/util/note_linker_spec.rb

@@ -1,68 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe NoteLinker do
-  describe '.find_unlinked_pitches' do
-    {
-      'note has no pitches' => [Note.quarter,[]],
-      'note has 1 pitch, no links' => [Note.quarter([C4]),[C4]],
-      'note has 2 pitches, no links' => [Note.quarter([C4,E4]),[C4,E4]],
-      'note has 1 pitch, which is linked' => [Note.quarter([C4], links: {C4 => Link::Tie.new} ),[]],
-      'note has 2 pitch, 1 of which is linked' => [Note.quarter([C4,E4], links: {C4 => Link::Tie.new} ),[E4]],
-      'note has 2 pitches, both of which are linked' => [Note.quarter([C4,E4], links: {C4 => Link::Tie.new, E4 => Link::Tie.new} ),[]],
-      'note has 1 pitch, and 1 unrelated link' => [Note.quarter([C4], links: {D4 => Link::Tie.new}),[C4]],
-      'note has 2 pitch, and 2 unrelated links' => [Note.quarter([C4,E4], links: {D4 => Link::Tie.new, F4 => Link::Tie.new}),[C4,E4]],
-    }.each do |descr,given_expected|
-      context descr do
-        given, expected = given_expected
-        it "should return #{expected}" do
-          actual = NoteLinker.find_unlinked_pitches(given)
-          actual.should eq(expected)
-        end
-      end
-    end
-  end
-  
-  describe '.find_untargeted_pitches' do
-    {
-      'note has no pitches, next note has no pitches' => [Note.quarter,Note.quarter,[]],
-      'note has no pitches, next note has 3 pitch' => [Note.quarter,Note.quarter([C3,E3,F3]),[C3,E3,F3]],
-      'note has 3 pitches + no links, next note has 2 pitches' => [Note.quarter([C3,E3,F3]),Note.quarter([D2,F2]),[D2,F2]],
-      'note has 1 pitch + 1 unrelated link, next note has 1 pitch' => [Note.quarter([C3], links: {C3 => Link::Slur.new(C2)}),Note.quarter([D2]),[D2]],
-      'note has 1 pitch + 1 related link, next note has 1 pitch' => [Note.quarter([C3], links: {C3 => Link::Slur.new(D2)}),Note.quarter([D2]),[]],
-      'note has 2 pitches + 2 related link, next note has 2 pitches' => [Note.quarter([C3,E3], links: {C3 => Link::Slur.new(D2), E3 => Link::Slur.new(E2) }),Note.quarter([D2,E2]),[]],
-      'note has 2 pitches + 1 unrelated link, next note has 2 pitches' => [Note.quarter([C3,E3], links: {C3 => Link::Slur.new(D2), E3 => Link::Slur.new(F2) }),Note.quarter([D2,E2]),[E2]],
-    }.each do |descr,given_expected|
-      context descr do
-        given_note, given_next_note, expected = given_expected
-        it "should return #{expected}" do
-          actual = NoteLinker.find_untargeted_pitches(given_note, given_next_note)
-          actual.should eq(expected)
-        end
-      end
-    end    
-  end
-  
-  describe '.fully_link' do
-    [
-      [ Note.quarter([C4,E4,G4]), Note.quarter, Note.quarter([C4,E4,G4]) ],
-      [ Note.quarter([G4]), Note.quarter([A4]), Note.quarter([G4], links: {G4 => Link::Slur.new(A4)}) ],
-      [
-        Note.quarter([G4,A4]),
-        Note.quarter([A4]),
-        Note.quarter([G4,A4], links: {A4 => Link::Slur.new(A4)})
-      ],
-      [
-        Note.quarter([G4,A4], links: {A4 => Link::Slur.new(B4)}),
-        Note.quarter([A4,B4]),
-        Note.quarter([G4,A4], links: {G4 => Link::Slur.new(A4), A4 => Link::Slur.new(B4)})
-      ],
-    ].each do |note,next_note,modified|
-      context "given note: #{note.to_s}, next_note: #{next_note.to_s}" do
-        it "should modifiy note to equal #{modified.to_s}" do
-          NoteLinker.fully_link(note, next_note, Link::Slur)
-          note.should eq(modified)
-        end
-      end
-    end
-  end
-end