musicality 0.8.0 → 0.9.0

data/spec/performance/midi/midi_util_spec.rb

@@ -38,8 +38,8 @@ describe MidiUtil do
     
     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
-        expect { MidiUtil.pitch_to_notenum(Ab9) }.to raise_error
+        expect { MidiUtil.pitch_to_notenum(Pitch.new(octave:-2)) }.to raise_error(KeyError)
+        expect { MidiUtil.pitch_to_notenum(Ab9) }.to raise_error(KeyError)
       end
     end
   end
@@ -91,19 +91,33 @@ describe MidiUtil do
   end
   
   describe 'note_velocity' do
-    context 'given true' do
-      it 'should return a higher value than when given false' do
-        MidiUtil.note_velocity(true).should be > MidiUtil.note_velocity(false)
+    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)
+      end
+
+      it 'should return a value between 0 and 127' do
+        MidiUtil.note_velocity(Attack::NORMAL).should 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)
       end
       
       it 'should return a value between 0 and 127' do
-        MidiUtil.note_velocity(true).should be_between(0,127)
+        MidiUtil.note_velocity(Attack::TENUTO).should be_between(0,127)
       end
     end
     
-    context 'given false' do
+    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)
+      end
+
       it 'should return a value between 0 and 127' do
-        MidiUtil.note_velocity(false).should be_between(0,127)
+        MidiUtil.note_velocity(Attack::ACCENT).should be_between(0,127)
       end
     end
   end

data/spec/performance/midi/part_sequencer_spec.rb

@@ -21,9 +21,9 @@ describe PartSequencer do
       @track.name.should eq(@part_name)
     end
     
-    it 'should assign program number via ProgramChange event' do
+    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)
+      event.program.should eq(@program_num-1)
     end
     
     it 'should assign the given channel number to all channel events' do

data/spec/performance/midi/score_sequencer_spec.rb

@@ -8,12 +8,13 @@ describe ScoreSequencer 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)
-      @part2 = Part.new(Dynamics::FF, notes: "/4E4 3/4F4 /4E4".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 ])
       @score = Score::Timed.new(program: [0..2.5],
-                                parts: {@part1_name => @part2, @part2_name => @part2})
-      @instr_map = {@part1_name => 33, @part2_name => 25}
-      @midi_seq = ScoreSequencer.new(@score).make_midi_seq(@instr_map)
+                                parts: {@part1_name => @part1, @part2_name => @part2})
+      @midi_seq = ScoreSequencer.new(@score).make_midi_seq
     end
     
     it 'should return MIDI::Sequence' do
@@ -29,11 +30,12 @@ describe ScoreSequencer do
       @midi_seq.tracks[2].name.should eq(@part2_name)
     end
     
-    it 'should assign program number from given instrument map hash' do
-      [ @midi_seq.tracks[1], @midi_seq.tracks[2] ].each do |track|
-        prog_event = track.events.select {|x| x.is_a? MIDI::ProgramChange }.first
-        prog_event.program.should eq(@instr_map[track.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)
+
+      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)
     end
     
     it 'should assign different channel to each part track' do

data/spec/performance/midi/score_sequencing_spec.rb

@@ -21,9 +21,9 @@ describe Score::Timed do
   end  
 end
 
-describe Score::TempoBased do
+describe Score::Tempo do
   before :all do
-    @score = Score::Measured.new(TWO_FOUR, 120) do |s|
+    @score = Score::Tempo.new(TWO_FOUR, 120) do |s|
       s.parts["rhand"] = Part.new(Dynamics::MF) do |p|
         p.notes += ("/4C4 "*2 + "/4G4 "*2 +
                     "/4A4 "*2 + "/2G4").to_notes

data/spec/performance/model/note_sequence_spec.rb

@@ -2,146 +2,53 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe NoteSequence do
   describe '#initialize' do
-    it 'should assign given start, stop, pitches and attacks' do
-      start, stop = 15, 22
-      pitches = { 15 => F2, 16 => G2, 16.1 => Ab2, 21.99 => C2 }
-      attacks = { 15 => ACCENTED, 17 => UNACCENTED, 18 => ACCENTED }
-      seq = NoteSequence.new(start,stop,pitches,attacks)
-      seq.start.should eq(start)
-      seq.stop.should eq(stop)
-      seq.pitches.should eq(pitches)
-      seq.attacks.should eq(attacks)
-    end
-    
-    it 'should raise ArgumentError if start offset >= stop offset' do
-      expect do
-        NoteSequence.new(20,19, { 20 => C4 }, { 20 => UNACCENTED })
-      end.to raise_error(ArgumentError)
-    end
-    
-    it 'should raise ArgumentError if no pitches are given' do
-      expect do
-        NoteSequence.new(20,21, {}, { 20 => UNACCENTED })
-      end.to raise_error(ArgumentError)
-    end
-    
-    it 'should raise ArgumentError if no attacks are given' do
-      expect do
-        NoteSequence.new(20,21, { 20 => C4 }, {})
-      end.to raise_error(ArgumentError)
-    end
-    
-    it 'should raise ArgumentError if no start pitch is given' do
-      expect do
-        NoteSequence.new(20,21, { 20.1 => C4 }, { 20 => UNACCENTED })
-      end.to raise_error(ArgumentError)
-    end
-    
-    it 'should raise ArgumentError if no start attack is given' do
-      expect do
-        NoteSequence.new(20,21, { 20 => C4 }, { 20.1 => UNACCENTED })
-      end.to raise_error(ArgumentError)
-    end
-    
-    it 'should raise ArgumentError if any pitch offset is not between start..stop' do
-      expect do
-        NoteSequence.new(20,21, { 20 => C4, 21.01 => D4 }, { 20 => UNACCENTED })
-      end.to raise_error(ArgumentError)
-      
-      expect do
-        NoteSequence.new(20,21, { 20 => C4, 19.99 => D4 }, { 20 => UNACCENTED })
-      end.to raise_error(ArgumentError)
-    end
-    
-    it 'should raise ArgumentError if any attack offset is not between start..stop' do
-      expect do
-        NoteSequence.new(20,21, { 20 => C4 }, { 20 => UNACCENTED, 21.01 => ACCENTED })
-      end.to raise_error(ArgumentError)
+    it 'should assign given offset, separation, and elements' do
+      offset = 12
+      separation = Separation::TENUTO
+      elements = [ NoteSequence::Element.new(2, G2, Attack::NORMAL) ]
       
-      expect do
-        NoteSequence.new(20,21, { 20 => C4 }, { 20 => UNACCENTED, 19.99 => ACCENTED })
-      end.to raise_error(ArgumentError)
+      seq = NoteSequence.new(offset, separation, elements)
+      expect(seq.offset).to eq(offset)
+      expect(seq.separation).to eq(separation)
+      expect(seq.elements).to eq(elements)
     end
   end
+
+  before :all do
+    @element_arys = [
+      [ NoteSequence::Element.new(0.5, B2, Attack::NONE) ],
+      [ NoteSequence::Element.new(0.5, A2, Attack::NORMAL), 
+        NoteSequence::Element.new(0.5, B2, Attack::NONE),
+        NoteSequence::Element.new(0.5, B2, Attack::ACCENT) ],
+    ]
+    @offsets = [ 0, -5, 7, 77 ]
+  end
   
-  describe '.from_elements' do
-    it 'should raise ArgumentError if no elements are given' do
-      expect { NoteSequence.from_elements(2,[]) }.to raise_error(ArgumentError)
-    end
-    
-    context 'single element' do
-      before :all do
-        @offset = 0
-        @el = FinalElement.new(2, C2, true, NORMAL)
-        @seq = NoteSequence.from_elements(@offset, [ @el ])
-        
-      end
-      
-      it 'should return a NoteSequence' do
-        @seq.should be_a NoteSequence
-      end
-      
-      it 'should set start offset to given offset' do
-        @seq.start.should eq(@offset)
-      end
-      
-      it 'should set stop offset no more than "duration of first element" away from start' do
-        (@seq.stop - @seq.start).should be <= @el.duration
-      end
-      
-      it 'should set start pitch according to element pitch' do
-        @seq.pitches[@seq.start].should eq(@el.pitch)
-      end
-      
-      it 'should set start attack according to element.accented' do
-        @seq.attacks[@seq.start].accented?.should eq(@el.accented)
-      end
-    end
-    
-    context 'multi-element' do
-      before :all do
-        @offset = 1.5
-        @els = [
-          SlurredElement.new(1.0, A2, false),
-          LegatoElement.new(1.1, B2, false),
-          SlurredElement.new(1.2, C2, false),
-          LegatoElement.new(1.3, B2, false),
-          FinalElement.new(1.4, A2, false, NORMAL)
-        ]
-        @seq = NoteSequence.from_elements(@offset, @els)
-      end
-      
-      it 'should place pitches according to element duration' do
-        offset = @offset
-        @els.each do |el|
-          @seq.pitches.should have_key(offset)
-          @seq.pitches[offset].should eq(el.pitch)
-          offset += el.duration
-        end
-      end
-      
-      it 'should place attacks at beginning and following non-slur elements' do
-        @seq.attacks.should have_key(@offset)
-        
-        offset = @offset + @els.first.duration
-        (1...@els.size).each do |i|
-          unless @els[i-1].slurred?
-            @seq.attacks.should have_key(offset)
+  describe '#offsets' do
+    context 'with no elements' do
+      it 'should raise RuntimeError' do
+        expect do
+          seq = NoteSequence.new(0, Separation::NORMAL, [])
+          seq.offsets
+        end.to raise_error(RuntimeError)
+      end
+    end
+    
+    context 'with at least one element' do
+      it 'should return offsets of each element' do
+        @offsets.each do |offset|
+          @element_arys.each do |els|
+            seq = NoteSequence.new(offset, Separation::NORMAL, els)
+            offsets = seq.offsets
+            expect(offsets.size).to eq(els.size)
+            expect(offsets[0]).to eq(seq.offset)
+            (1...offsets.size).each do |i|
+              dur = offsets[i] - offsets[i-1]
+              expect(dur).to eq(els[i-1].duration)
+            end
           end
-          offset += @els[i].duration
         end
       end
     end
-    
-    context 'elements contain slur to same pitch' do
-      it 'should not add same pitch nor attack for second element' do
-        els = [ SlurredElement.new(1, C4, false), FinalElement.new(1, C4, false, NORMAL) ]
-        seq = NoteSequence.from_elements(0, els)
-        seq.pitches.should have_key(0)
-        seq.pitches.should_not have_key(1)
-        seq.attacks.should have_key(0)
-        seq.attacks.should_not have_key(1)
-      end
-    end
   end
-end
+end

data/spec/printing/note_engraving_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Note do
+  describe '#fractional_subdurs' do
+    context 'duration that is entirely whole' 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
+        end
+      end
+    end
+
+    context 'duration that is entirely fractional' do
+      context 'combination of multiples of power-of-two fractions' do
+        [
+          [Rational(3,8),Rational(7,32)],
+          [Rational(1,8),Rational(3,16),Rational(5,32)],
+          [Rational(1,2),Rational(3,32),Rational(5,64),Rational(17,128)],
+        ].each do |subdurs|
+          dur = subdurs.inject(0.to_r,:+)
+          n = Note.new(dur)
+          subdurs2 = n.fractional_subdurs(Rational(1,512))
+
+          it 'should return descending power-of-two fractions' do
+            subdurs2.should eq subdurs2.sort.reverse
+          end
+
+          it 'should return fractions that sum to note duration' do
+            subdurs2.inject(0.to_r,:+).should eq(dur)
+          end
+        end
+      end
+    end
+
+    context 'duration that has whole and fractional part' do
+      [
+        [6,Rational(3,8),Rational(11,16)],
+        [3,Rational(1,8),Rational(5,8),Rational(5,32)],
+        [1,Rational(3,32),Rational(1,2),Rational(5,4)],
+      ].each do |subdurs|
+        dur = subdurs.inject(0.to_r,:+)
+        n = Note.new(dur)
+        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)
+        end
+      end
+    end
+  end
+
+  describe '#to_lilypond' do
+    context 'duration is entirely whole' do
+      context 'no pitches' do
+        it 'should return "r1"s' do
+        end
+      end
+    end
+  end
+
+  #   context 'no pitches' do
+  #     it 'should represent note pieces with "r"' do
+
+  #     end
+  #   end
+
+  #   it 'should '
+  #   it 'should separate pieces with a "~" and a space' do
+  #     [2,3+Rational(1,2)].each do |dur|
+  #       [[],[Eb3],[C2,Gb4]].each do |pitches|
+  #         n = Note.new(dur,pitches)
+  #         s = n.to_lilypond
+  #         pieces = s.split("~ ")
+  #         pieces.
+  #       end
+  #     end
+  #   end
+
+
+    #    and duration with deno'
+    #   context 'simple power-of-two note duration' 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)
+    #       end
+    #     end
+    #   end
+
+    #   context 'dotted power-of-two note duration less than 1 (e.g. 3/4 or 3/2)' 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 + ".")
+    #       end
+    #     end
+    #   end
+
+    #   context 'compound duration reducible only to simple power-of-two durations (not dotted)' do
+    #     it 'should return a string with r\'s plus the duration denominators' do
+    #       [
+    #         [1,0.25],
+    #         [0.5,0.125],
+    #         [0.25,0.0625],
+    #         [0.5,0.125,0.03125]
+    #       ].each do |subdurs|
+    #         dur = subdurs.inject(0.to_r,:+)
+    #         n = Note.new(dur)
+    #         strs = n.to_lilypond.split
+    #         strs.size.should eq subdurs.size
+    #         strs.each_with_index do |str,i|
+    #           str.should eq("r" + subdurs[i].to_r.denominator.to_s)
+    #         end
+    #       end
+    #     end
+    #   end
+
+    #   context 'simple triplet duration' 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}}")
+    #       end
+    #     end
+    #   end
+    # end
+
+    # context 'simple power-of-two note duration' do
+    #   context 'one pitch' do
+    #     it 'should return a string with Lilypond pitch plus the duration denominator' 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)
+    #         end
+    #       end
+    #     end
+    #   end
+
+    #   context 'multiple pitch' do
+    #     it 'should return a string with Lilypond pitches in angle brackets plus the duration denominator' 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)
+    #       end
+    #     end
+    #   end
+    # end
+
+    # context 'dotted power-of-two note duration less than 1 (e.g. 3/4 or 3/2)' do
+    #   context 'one pitch' do
+    #     it 'should return a string with Lilypond pitch plus half the duration denominator plus a "."' 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 + ".")
+    #         end
+    #       end
+    #     end
+    #   end
+
+    #   context 'multiple pitch' do
+    #     it 'should return a string with Lilypond pitches in angle brackets plus half the duration denominator plus a "."' 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 + ".")
+    #       end
+    #     end
+    #   end
+    # end
+
+    # context 'compound duration reducible only to simple power-of-two durations (not dotted)' do
+    #   context 'one pitch' do
+    #     it 'should return a string with Lilypond pitch plus the duration denominators, and a "~" if not the last piece' do
+    #       [
+    #         [1,0.25],
+    #         [0.5,0.125],
+    #         [0.25,0.0625],
+    #         [0.5,0.125,0.03125]
+    #       ].each do |subdurs|
+    #         [Gb3,Bb3,C4].each do |pitch|
+    #           dur = subdurs.inject(0.to_r,:+)
+    #           n = Note.new(dur,pitch)
+    #           str = n.to_lilypond
+    #           strs = str.split
+    #           strs.size.should 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 + "~")
+    #             else
+    #               str.should eq(pitch.to_lilypond + subdurs[i].to_r.denominator.to_s)
+    #             end
+    #           end
+    #         end
+    #       end
+    #     end
+    #   end
+
+    # end
+  # end
+end