musicality 0.11.1 → 0.12.0

data/spec/composition/model/scale_class_spec.rb

@@ -12,65 +12,65 @@ describe ScaleClass do
       end
     end
   end
-  
+
   describe '#intervals' do
     it 'should return intervals given to #initialize' do
       valid.each do |intervals|
-        ScaleClass.new(intervals).intervals.should eq(intervals)
+        expect(ScaleClass.new(intervals).intervals).to eq(intervals)
       end
     end
   end
-  
+
   describe '#==' do
     it 'should compare given enumerable to intervals' do
       valid.each do |intervals|
         sc = ScaleClass.new(intervals)
-        sc.should eq(intervals)
-        sc.should_not eq(intervals + [2])
+        expect(sc).to eq(intervals)
+        expect(sc).to_not eq(intervals + [2])
       end
     end
   end
-  
+
   describe '#rotate' do
     it 'should return a new ScaleClass, with rotated intervals' do
       valid.each do |intervals|
         sc = ScaleClass.new(intervals)
         [ 0, 1, -1, 4, -3, 2, 6 ].each do |n|
           sc2 = sc.rotate(n)
-          sc2.should_not be(sc)
-          sc2.should eq(intervals.rotate(n))
+          expect(sc2).to_not be(sc)
+          expect(sc2).to eq(intervals.rotate(n))
         end
       end
     end
-    
+
     it 'should rotate by 1, by default' do
       intervals = valid.first
-      ScaleClass.new(intervals).rotate.should eq(intervals.rotate(1))
+      expect(ScaleClass.new(intervals).rotate).to eq(intervals.rotate(1))
     end
   end
-  
+
   describe '#each' do
     before :all do
       @sc = ScaleClass.new(valid.first)
     end
-    
+
     context 'block given' do
       it 'should yield all interval values' do
         xs = []
         @sc.each do |x|
           xs.push(x)
         end
-        xs.should eq(@sc.intervals)
+        expect(xs).to eq(@sc.intervals)
       end
     end
-    
+
     context 'no block given' do
       it 'should return an enumerator' do
-        @sc.each.should be_a Enumerator
+        expect(@sc.each).to be_a Enumerator
       end
     end
   end
-  
+
   describe '#to_pitch_seq' do
     before :all do
       @sc = ScaleClass.new([2,2,1,2,2,2,1])
@@ -79,20 +79,20 @@ describe ScaleClass do
       @prev_octave = [C3,D3,E3,F3,G3,A3,B3,C4]
       @pseq = @sc.to_pitch_seq(@start_pitch)
     end
-    
+
     it 'should return a AddingSequence' do
-      @pseq.should be_a AddingSequence
+      expect(@pseq).to be_a AddingSequence
     end
-    
+
     it 'should be centered at given start pitch' do
-      @pseq.at(0).should eq(@start_pitch)
+      expect(@pseq.at(0)).to eq(@start_pitch)
     end
-    
+
     it 'should walk forward/backward through scale' do
-      @pseq.take(8).to_a.should eq(@first_octave)
-      @pseq.over(0...8).to_a.should eq(@first_octave)
-      @pseq.take_back(7).to_a.should eq(@prev_octave.reverse.drop(1))
-      @pseq.over(-7..0).to_a.should eq(@prev_octave)
+      expect(@pseq.take(8).to_a).to eq(@first_octave)
+      expect(@pseq.over(0...8).to_a).to eq(@first_octave)
+      expect(@pseq.take_back(7).to_a).to eq(@prev_octave.reverse.drop(1))
+      expect(@pseq.over(-7..0).to_a).to eq(@prev_octave)
     end
   end
-end
+end

data/spec/composition/model/scale_spec.rb

@@ -11,16 +11,16 @@ describe Scale do
 
   describe '#pitch_class' do
     it 'should return the pitch class given to #initialize' do
-      @scale.pitch_class.should eq(@pc)
+      expect(@scale.pitch_class).to eq(@pc)
     end
   end
-  
+
   describe '#size' do
     it 'should return the size of the scale intervals' do
-      @scale.size.should eq(@intervals.size)
+      expect(@scale.size).to eq(@intervals.size)
     end
   end
-  
+
   describe '#transpose' do
     before :all do
       @diff2 = 3
@@ -28,25 +28,25 @@ describe Scale do
       @diff3 = -5
       @scale3 = @scale.transpose(@diff3)
     end
-    
+
     it 'should return a new Scale' do
-      @scale2.should be_a Scale
-      @scale2.should_not be @scale
-      @scale3.should be_a Scale
-      @scale3.should_not be @scale
+      expect(@scale2).to be_a Scale
+      expect(@scale2).to_not be @scale
+      expect(@scale3).to be_a Scale
+      expect(@scale3).to_not be @scale
     end
-    
+
     it 'should return a scale with same intervals' do
-      @scale2.intervals.should eq @scale.intervals
-      @scale3.intervals.should eq @scale.intervals
+      expect(@scale2.intervals).to eq @scale.intervals
+      expect(@scale3.intervals).to eq @scale.intervals
     end
-    
+
     it 'should return a scale with a shifted pitch class' do
-      @scale2.pitch_class.should eq((@scale.pitch_class + @diff2).to_pc)
-      @scale3.pitch_class.should eq((@scale.pitch_class + @diff3).to_pc)
+      expect(@scale2.pitch_class).to eq((@scale.pitch_class + @diff2).to_pc)
+      expect(@scale3.pitch_class).to eq((@scale.pitch_class + @diff3).to_pc)
     end
   end
-  
+
   describe '#rotate' do
     before :all do
       @n2 = 5
@@ -54,57 +54,57 @@ describe Scale do
       @n3 = -3
       @scale3 = @scale.rotate(@n3)
     end
-    
+
     it 'should return a new Scale' do
-      @scale2.should be_a Scale
-      @scale2.should_not be @scale
-      @scale3.should be_a Scale
-      @scale3.should_not be @scale
+      expect(@scale2).to be_a Scale
+      expect(@scale2).to_not be @scale
+      expect(@scale3).to be_a Scale
+      expect(@scale3).to_not be @scale
     end
-    
+
     it 'should return a scale with rotated intervals' do
-      @scale2.intervals.should eq @scale.intervals.rotate(@n2)
-      @scale3.intervals.should eq @scale.intervals.rotate(@n3)
+      expect(@scale2.intervals).to eq @scale.intervals.rotate(@n2)
+      expect(@scale3.intervals).to eq @scale.intervals.rotate(@n3)
     end
-    
+
     it 'should return a scale with a shifted pitch class' do
       pc2 = (AddingSequence.new(@scale.intervals).at(@n2) + @scale.pitch_class).to_pc
-      @scale2.pitch_class.should eq(pc2)
+      expect(@scale2.pitch_class).to eq(pc2)
       pc3 = (AddingSequence.new(@scale.intervals).at(@n3) + @scale.pitch_class).to_pc
-      @scale3.pitch_class.should eq(pc3)
+      expect(@scale3.pitch_class).to eq(pc3)
     end
   end
-  
+
   describe '#at_octave' do
     before :all do
       @octave = 2
       @pitch_seq = @scale.at_octave(@octave)
       @start_pitch = @pitch_seq.at(0)
     end
-  
+
     it 'should return a bi-infinite sequence' do
-      @pitch_seq.should be_a BiInfiniteSequence
+      expect(@pitch_seq).to be_a BiInfiniteSequence
     end
-    
+
     it 'should start sequence at scale pitch class and given octave' do
-      @start_pitch.semitone.should eq(@scale.pitch_class)
-      @start_pitch.octave.should eq(@octave)
+      expect(@start_pitch.semitone).to eq(@scale.pitch_class)
+      expect(@start_pitch.octave).to eq(@octave)
     end
-    
+
     it 'should make sequence that proceeds forwards along scale intervals' do
       first_pitches = @pitch_seq.over(0..@scale.intervals.size).to_a
       first_pitches[1..-1].each_with_index do |pitch,i|
         diff = pitch.diff(first_pitches[i])
-        diff.should eq(@scale.intervals[i])
+        expect(diff).to eq(@scale.intervals[i])
       end
     end
-    
+
     it 'should make sequence that proceeds backwards along scale intervals' do
       first_pitches = @pitch_seq.over(-@scale.intervals.size..0).to_a
       first_pitches[1..-1].each_with_index do |pitch,i|
         diff = pitch.diff(first_pitches[i])
-        diff.should eq(@scale.intervals[i])
+        expect(diff).to eq(@scale.intervals[i])
       end
     end
   end
-end
+end

data/spec/composition/sequencing/drum_machine/drum_machine_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+describe DrumMachine do
+  describe '#initialize' do
+    context 'given no patterns' do
+      it 'should raise ArgumentError' do
+        expect { DrumMachine.new([]) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'given 1 pattern with 2 parts' do
+      before :all do
+        @pattern = DrumPattern.new(1, DrumParts::SNARE_DRUM => [1,2,1], DrumParts::CLOSED_HI_HAT => [1,1])
+        @dm = DrumMachine.new([@pattern])
+      end
+
+      it 'should produce a NoteArray sequenceables for each part in pattern' do
+        expect(@dm.part_sequenceables).to have_key(DrumParts::SNARE_DRUM)
+        expect(@dm.part_sequenceables[DrumParts::SNARE_DRUM]).to be_a NoteArray
+
+        expect(@dm.part_sequenceables).to have_key(DrumParts::CLOSED_HI_HAT)
+        expect(@dm.part_sequenceables[DrumParts::CLOSED_HI_HAT]).to be_a NoteArray
+      end
+
+      it 'should provide part notes from the pattern to the NoteArray' do
+        expect(@dm.part_sequenceables[DrumParts::SNARE_DRUM].notes).to eq(@pattern.part_notes[DrumParts::SNARE_DRUM])
+        expect(@dm.part_sequenceables[DrumParts::CLOSED_HI_HAT].notes).to eq(@pattern.part_notes[DrumParts::CLOSED_HI_HAT])
+      end
+    end
+
+    context 'given 2 patterns' do
+      context 'first pattern contains only part DrumParts::SNARE_DRUM, second pattern contains only part DrumParts::CLOSED_HI_HAT' do
+        before :all do
+          @pattern1 = DrumPattern.new(2, DrumParts::SNARE_DRUM => [1,2,1])
+          @pattern2 = DrumPattern.new(1, DrumParts::CLOSED_HI_HAT => [1,1])
+          @dm = DrumMachine.new([@pattern1, @pattern2])
+        end
+
+        it 'should produce a NoteArray sequenceables for each part in pattern' do
+          expect(@dm.part_sequenceables).to have_key(DrumParts::SNARE_DRUM)
+          expect(@dm.part_sequenceables[DrumParts::SNARE_DRUM]).to be_a NoteArray
+
+          expect(@dm.part_sequenceables).to have_key(DrumParts::CLOSED_HI_HAT)
+          expect(@dm.part_sequenceables[DrumParts::CLOSED_HI_HAT]).to be_a NoteArray
+        end
+
+        it 'should start part DrumParts::SNARE_DRUM with notes from the first pattern' do
+          first_notes = @pattern1.part_notes[DrumParts::SNARE_DRUM]
+          expect(@dm.part_sequenceables[DrumParts::SNARE_DRUM].notes.slice(0...-1)).to eq(first_notes)
+        end
+
+        it 'should end part DrumParts::CLOSED_HI_HAT with notes from the second pattern' do
+          last_notes = @pattern2.part_notes[DrumParts::CLOSED_HI_HAT]
+          expect(@dm.part_sequenceables[DrumParts::CLOSED_HI_HAT].notes.slice(1..-1)).to eq(last_notes)
+        end
+
+        it 'should start part DrumParts::CLOSED_HI_HAT with a rest note that has same duration as the first pattern' do
+          expect(@dm.part_sequenceables[DrumParts::CLOSED_HI_HAT].notes.first).to eq(Note.new(@pattern1.duration))
+        end
+
+        it 'should end part DrumParts::SNARE_DRUM with a rest note that has same duration as the second pattern' do
+          expect(@dm.part_sequenceables[DrumParts::SNARE_DRUM].notes.last).to eq(Note.new(@pattern2.duration))
+        end
+      end
+    end
+  end
+end

data/spec/composition/sequencing/drum_machine/drum_pattern_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+def notes_duration(notes)
+  notes.map {|note| note.duration }.inject(0, :+)
+end
+
+describe DrumPattern do
+  describe '#initialize' do
+    context 'no part_name_portions given' do
+      it 'should produce no part_notes' do
+        expect(DrumPattern.new(0, {}).part_notes).to be_empty
+      end
+    end
+
+    context 'one part_name_portions given' do
+      context 'total duration of 0 given' do
+        it 'should raise ArgumentError' do
+          expect { DrumPattern.new(0, DrumParts::SNARE_DRUM => [1,1]) }.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'total duration of 1 given' do
+        it 'should produce 1 part_notes with total duration of 1' do
+          dp = DrumPattern.new(1, DrumParts::SNARE_DRUM => [1,1])
+          expect(dp.part_notes.size).to eq(1)
+          expect(dp.part_notes.keys[0]).to eq(DrumParts::SNARE_DRUM)
+          expect(notes_duration(dp.part_notes.values[0])).to eq(1)
+        end
+      end
+    end
+
+    context 'multiple part_name_portions given' do
+      context 'total duration of 2 given' do
+        before :all do
+          @part_name_portions = {DrumParts::SNARE_DRUM => [1,1], DrumParts::CLOSED_HI_HAT => [1,1,3]}
+          @duration = 2
+          @dp = DrumPattern.new(@duration, @part_name_portions)
+        end
+
+        it 'should produce as many part_notes as were given' do
+          expect(@dp.part_notes.size).to eq(@part_name_portions.size)
+        end
+
+        it 'should produce part_notes that match given part_name_portions' do
+          @part_name_portions.keys.each do |part_name|
+            expect(@dp.part_notes).to have_key(part_name)
+          end
+        end
+
+        it 'should produce all part_notes with total duration equal to that of pattern' do
+          @dp.part_notes.values.each do |notes|
+            expect(notes_duration(notes)).to eq(@duration)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/composition/sequencing/note_array_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe NoteArray do
+  describe '#initialize' do
+    context 'given empty array' do
+      it 'should raise ArgumentError' do
+        expect { NoteArray.new([]) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#next_note' do
+    context '1 note in array' do
+      before :each do
+        @note = Note.whole
+        @note_array = NoteArray.new([@note])
+      end
+
+      context 'next_note not called yet' do
+        it 'should produce the only note in the array' do
+          expect(@note_array.next_note).to eq(@note)
+        end
+      end
+
+      context 'next already called once' do
+        it 'should produce the only note array' do
+          @note_array.next_note
+          expect(@note_array.next_note).to eq(@note)
+        end
+      end
+    end
+
+    context '2 notes in array' do
+      before :each do
+        @notes = [ Note.whole, Note.quarter ]
+        @note_array = NoteArray.new(@notes)
+      end
+
+      context 'next_note not called yet' do
+        it 'should produce the first note' do
+          expect(@note_array.next_note).to eq(@notes[0])
+        end
+      end
+
+      context 'next_note already called once' do
+        it 'should produce the second note' do
+          @note_array.next_note
+          expect(@note_array.next_note).to eq(@notes[1])
+        end
+      end
+
+      context 'next_note already called twice' do
+        it 'should produce the first note' do
+          @note_array.next_note
+          @note_array.next_note
+          expect(@note_array.next_note).to eq(@notes[0])
+        end
+      end
+    end
+  end
+
+  describe '#reset' do
+    context '3 notes in array' do
+      before :each do
+        @notes = [ Note.eighth, Note.eighth, Note.quarter ]
+        @note_array = NoteArray.new(@notes)
+      end
+
+      context 'next_note not called yet' do
+        it 'should have no effect, so a follow-up call to #next_note still returns first note' do
+          @note_array.reset
+          expect(@note_array.next_note).to eq(@notes[0])
+        end
+      end
+
+      context 'next_note already called once' do
+        it 'should result in a follow-up call to #next_note returning the first note' do
+          @note_array.next_note
+          @note_array.reset
+          expect(@note_array.next_note).to eq(@notes[0])
+        end
+      end
+
+      context 'next_note already called twice' do
+        it 'should result in a follow-up call to #next_note returning the first note' do
+          @note_array.next_note
+          @note_array.next_note
+          @note_array.reset
+          expect(@note_array.next_note).to eq(@notes[0])
+        end
+      end
+    end
+  end
+end

data/spec/composition/sequencing/note_fifo_spec.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Sequencer::NoteFIFO do
+  describe '#initialize' do
+    it 'should add the given notes to the FIFO' do
+      notes = [Note.half, Note.quarter]
+      fifo = Sequencer::NoteFIFO.new(notes)
+      expect(fifo.notes).to eq(notes)
+      expect(fifo.duration).to eq(Rational(3,4))
+    end
+  end
+
+  describe '#empty?' do
+    context 'FIFO does not have notes' do
+      it 'should return true' do
+        # initialized without notes
+        expect(Sequencer::NoteFIFO.new.empty?).to be_truthy
+
+        # or removed later
+        fifo = Sequencer::NoteFIFO.new
+        fifo.remove_notes(fifo.duration)
+        expect(fifo.empty?).to be_truthy
+      end
+    end
+
+    context 'FIFO has notes' do
+      it 'should return false' do
+        # initialized with notes
+        notes = [Note.whole, Note.half, Note.quarter]
+        expect(Sequencer::NoteFIFO.new(notes).empty?).to be_falsey
+
+        # or added later
+        fifo = Sequencer::NoteFIFO.new
+        fifo.add_notes(notes)
+        expect(fifo.empty?).to be_falsey
+      end
+    end
+  end
+
+  describe '#add_notes' do
+    context 'given empty array' do
+      before :all do
+        @notes = [Note.whole, Note.half, Note.quarter]
+        @fifo = Sequencer::NoteFIFO.new(@notes)
+        @prev_duration = @fifo.duration
+        @fifo.add_notes([])
+      end
+
+      it 'should not change the current note array' do
+        expect(@fifo.notes).to eq(@notes)
+      end
+
+      it 'should not change the duration' do
+        expect(@fifo.duration).to eq(@prev_duration)
+      end
+    end
+
+    context 'given array of one note' do
+      before :all do
+        @notes = [Note.quarter, Note.half]
+        @fifo = Sequencer::NoteFIFO.new(@notes)
+        @prev_duration = @fifo.duration
+        @new_note = Note.whole
+        @fifo.add_notes([@new_note])
+      end
+
+      it 'should append the given note to the FIFO note array' do
+        expect(@fifo.notes).to eq(@notes + [@new_note])
+      end
+
+      it 'should increase the FIFO duration by the total duration of the given note' do
+        expect(@fifo.duration).to eq(@prev_duration + @new_note.duration)
+      end
+    end
+
+    context 'given an array of more than one note' do
+      before :all do
+        @notes = [Note.quarter, Note.half]
+        @fifo = Sequencer::NoteFIFO.new(@notes)
+        @prev_duration = @fifo.duration
+        @new_notes = [ Note.whole, Note.quarter ]
+        @fifo.add_notes(@new_notes)
+      end
+
+      it 'should append the given notes to the FIFO note array' do
+        expect(@fifo.notes).to eq(@notes + @new_notes)
+      end
+
+      it 'should increase the FIFO duration by the total duration of the given notes' do
+        add_dur = @new_notes.inject(0){|sum, n| sum + n.duration }
+        expect(@fifo.duration).to eq(@prev_duration + add_dur)
+      end
+    end
+  end
+
+  describe '#remove_notes' do
+    before :each do
+      @notes = [Note.whole, Note.half, Note.quarter]
+      @fifo = Sequencer::NoteFIFO.new(@notes)
+    end
+
+    context 'given negative target duration' do
+      it 'should raise ArgumentError' do
+        expect { @fifo.remove_notes(-1) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'given target duration greater than FIFO duration' do
+      it 'should raise ArgumentError' do
+        expect { @fifo.remove_notes(@fifo.duration + 1) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'given target_duration of 0' do
+      it 'should return an empty array and not affect FIFO' do
+        removed_notes = @fifo.remove_notes(0)
+        expect(removed_notes).to be_empty
+        expect(@fifo.notes).to eq(@notes)
+      end
+    end
+
+    context 'given target duration equal to FIFO duration' do
+      it 'should empty FIFO and bring duration to 0' do
+        @fifo.remove_notes(@fifo.duration)
+        expect(@fifo.empty?).to be_truthy
+        expect(@fifo.duration).to eq(0)
+      end
+    end
+
+    context 'given positive target duration less than FIFO duration' do
+      context 'target duration lands exactly on note boundary' do
+        before :all do
+          @notes = [Note.whole, Note.half, Note.quarter]
+          @fifo = Sequencer::NoteFIFO.new(@notes)
+          @prev_fifo_dur = @fifo.duration
+          @target_dur = 1.5
+        end
+
+        it 'should reduce FIFO duration by the given target duration' do
+          @fifo.remove_notes(@target_dur)
+          expect(@fifo.duration).to eq(@prev_fifo_dur - @target_dur)
+        end
+
+        it 'should remove notes from the front of the FIFO, totally in tact' do
+          removed = @fifo.remove_notes(@target_dur)
+          expect(removed).to eq(@notes[0..1])
+          expect(@fifo.notes).to eq([@notes.last])
+        end
+      end
+
+      context 'target duration lands somewhere during one of the notes' do
+        before :each do
+          @notes = [Note.whole, Note.half([Pitches::C4]), Note.quarter]
+          @fifo = Sequencer::NoteFIFO.new(@notes)
+          @prev_fifo_dur = @fifo.duration
+          @target_dur = 1.25
+        end
+
+        it 'should reduce FIFO duration by the given target duration' do
+          @fifo.remove_notes(@target_dur)
+          expect(@fifo.duration).to eq(@prev_fifo_dur - @target_dur)
+        end
+
+        it 'should remove notes from the front of the FIFO, dividing the last one into two tied notes' do
+          expected_removed = [
+            Note.whole,
+            Note.quarter([Pitches::C4], links: { Pitches::C4 => Link::Tie.new })
+          ]
+
+          expected_remaining = [
+            Note.quarter([Pitches::C4]),
+            Note.quarter
+          ]
+
+          removed = @fifo.remove_notes(@target_dur)
+
+          expect(removed).to eq(expected_removed)
+          expect(@fifo.notes).to eq(expected_remaining)
+        end
+      end
+    end
+  end
+end