musicality 0.3.0 → 0.5.0

data/spec/composition/model/scale_class_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+valid = [ [2,2,1,2,2,2,1], [1]*12 ]
+
+describe ScaleClass do
+  describe '#initialize' do
+    context 'given non-positive intervals' do
+      it 'should raise NonPositiveError' do
+        [ [3,6,-1,4], [-1,13], [4,4,4,-1,1] ].each do |intervals|
+          expect { ScaleClass.new(intervals) }.to raise_error(NonPositiveError)
+        end
+      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)
+      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])
+      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))
+        end
+      end
+    end
+    
+    it 'should rotate by 1, by default' do
+      intervals = valid.first
+      ScaleClass.new(intervals).rotate.should 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)
+      end
+    end
+    
+    context 'no block given' do
+      it 'should return an enumerator' do
+        @sc.each.should be_a Enumerator
+      end
+    end
+  end
+  
+  describe '#to_pitch_seq' do
+    before :all do
+      @sc = ScaleClass.new([2,2,1,2,2,2,1])
+      @start_pitch = C4
+      @first_octave = [C4,D4,E4,F4,G4,A4,B4,C5]
+      @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
+    end
+    
+    it 'should be centered at given start pitch' do
+      @pseq.at(0).should 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)
+    end
+  end
+end

data/spec/composition/model/scale_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include PitchClasses
+
+describe Scale do
+  before :all do
+    @intervals = [2,2,1,2,2,2,1]
+    @pc = C
+    @scale = Scale.new(@pc,@intervals)
+  end
+
+  describe '#pitch_class' do
+    it 'should return the pitch class given to #initialize' do
+      @scale.pitch_class.should eq(@pc)
+    end
+  end
+  
+  describe '#size' do
+    it 'should return the size of the scale intervals' do
+      @scale.size.should eq(@intervals.size)
+    end
+  end
+  
+  describe '#transpose' do
+    before :all do
+      @diff2 = 3
+      @scale2 = @scale.transpose(@diff2)
+      @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
+    end
+    
+    it 'should return a scale with same intervals' do
+      @scale2.intervals.should eq @scale.intervals
+      @scale3.intervals.should 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)
+    end
+  end
+  
+  describe '#rotate' do
+    before :all do
+      @n2 = 5
+      @scale2 = @scale.rotate(@n2)
+      @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
+    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)
+    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)
+      pc3 = (AddingSequence.new(@scale.intervals).at(@n3) + @scale.pitch_class).to_pc
+      @scale3.pitch_class.should 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
+    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)
+    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])
+      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])
+      end
+    end
+  end
+end

data/spec/composition/note_generation_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'make_note' do
+  it 'should return a Note' do
+    make_note(0.3,C3).should be_a Note
+  end
+  
+  context 'given single pitch' do
+    it 'should have the given duration and pitch' do
+      n = make_note(0.3,C3)
+      n.duration.should eq(0.3)
+      n.pitches.should eq([C3])
+    end
+  end
+
+  context 'given pitch array' do
+    it 'should have the given duration and pitches' do
+      n = make_note(0.2,[C3,E3,Ab3])
+      n.duration.should eq(0.2)
+      n.pitches.should eq([C3,E3,Ab3])
+    end
+  end
+  
+  context 'given negative duration' do
+    it 'should have duration with same magnitude' do
+      make_note(-0.3,C3).duration.should eq(0.3)
+    end
+    
+    it 'should make a rest note (no pitches)' do
+      make_note(-0.3,[C3,E3]).pitches.should be_empty
+    end
+  end
+end
+
+describe 'make_notes' do
+  context 'given empty rhythm or pitch_groups' do
+    it 'should raise EmptyError' do
+      expect do
+        make_notes([],[A3,B3,C3])
+      end.to raise_error(EmptyError)
+      expect do
+        make_notes([2,2],[])
+      end.to raise_error(EmptyError)
+    end
+  end
+  
+  context 'given equal length rhtyhm and pitch_groups' do
+    it 'should produce same number of notes as both' do
+      make_notes([2,2,5],[A1,B1,C1]).size.should eq(3)
+    end
+  end
+  
+  context 'given longer rhythm than pitch_groups' do
+    before :all do
+      @rhythm = [4,3,3,1]
+      @pitch_groups = [[C1],[E2,G2]]
+      @notes = make_notes(@rhythm,@pitch_groups)
+    end
+    
+    it 'should produce same number of notes as rhythm.size' do
+      @notes.size.should eq(@rhythm.size)
+    end
+    
+    it 'should follow entire rhythm once' do
+      @notes.map {|n| n.duration}.should eq(@rhythm)
+    end
+    
+    it 'should cycle through pitch groups as necesary' do
+      @notes.map {|n| n.pitches}.should eq(@pitch_groups*2)
+    end
+  end
+  
+  context 'given longer pitch_groups than rhythm' do
+    before :all do
+      @rhythm = [4,3,1]
+      @pitch_groups = [[C1],[E2,G2],[F5,G5,A5],[F4],[Eb4],[G4]]
+      @notes = make_notes(@rhythm,@pitch_groups)
+    end
+    
+    it 'should produce same number of notes as pitch_groups.size' do
+      @notes.size.should eq(@pitch_groups.size)
+    end
+    
+    it 'should follow entire pitch_groups once' do
+      @notes.map {|n| n.pitches}.should eq(@pitch_groups)
+    end
+    
+    it 'should cycle through rhythm as necesary' do
+      @notes.map {|n| n.duration}.should eq(@rhythm*2)
+    end
+  end
+  
+  context 'given same-length pitch_groups and rhythm' do
+    before :all do
+      @rhythm = [4,3,1]
+      @pitch_groups = [[F4],[Eb4],[G4]]
+      @notes = make_notes(@rhythm,@pitch_groups)
+    end
+    
+    it 'should produce same number of notes as rhythm.size and pitch_groups.size' do
+      @notes.size.should eq(@pitch_groups.size)
+      @notes.size.should eq(@rhythm.size)
+    end
+    
+    it 'should follow entire rhythm once' do
+      @notes.map {|n| n.pitches}.should eq(@pitch_groups)
+    end
+    
+    it 'should follow entire pitch groups once' do
+      @notes.map {|n| n.duration}.should eq(@rhythm)
+    end
+  end
+end

data/spec/composition/transposition_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'transpose' do
+  it 'should map given notes to new notes, transposing by given diff' do
+    notes = "/4A2,C2 /4D2,F2,Gb2 /8 /8E4".to_notes
+    semitones = 3
+    notes2 = transpose(notes,semitones)
+    
+    notes2.size.should eq(notes.size)
+    notes2.each_index do |i|
+      notes2[i].pitches.each_with_index do |pitch2,j|
+        pitch = notes[i].pitches[j]
+        pitch2.diff(pitch).should eq(semitones)
+      end
+    end
+  end
+end

data/spec/composition/util/adding_sequence_spec.rb

@@ -0,0 +1,176 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AddingSequence do
+  describe '#initialize' do
+    context 'given an empty pattern' do
+      it 'should raise EmptyError' do
+        expect do
+          AddingSequence.new([])
+        end.to raise_error(EmptyError)
+      end
+    end
+  end
+  
+  describe '#pattern_size' do
+    it 'should return the pattern size' do
+      AddingSequence.new([1,2,3,4,5]).pattern_size.should eq(5)
+    end
+  end
+  
+  before :all do
+    @pattern = [2,-1,5,-4,3]
+    @start_value = 13
+    @seq = AddingSequence.new(@pattern,@start_value)
+  end
+  
+  describe '#at' do
+    context 'given single offset' do
+      context 'given offset of 0' do
+        it 'should return the start value' do
+          [ 0, -3, 7].each do |start_val|
+            AddingSequence.new(@pattern,start_val).at(0).should eq(start_val)
+          end
+        end
+      end
+    
+      context 'given offset > 0' do
+        it 'should keep adding on pattern elements to start_val until the given offset is reached' do
+          [1,2,3,5,8,15,45].each do |offset|
+            val = @seq.at(offset)
+            rep_seq = RepeatingSequence.new(@pattern)
+            val2 = rep_seq.take(offset).inject(@start_value,:+)
+            val.should eq(val2)
+          end
+        end
+      end
+      
+      context 'given offset < 0' do
+        it 'should keep suctracting pattern elements from start_val until the given offset is reached' do
+          [-1,-2,-3,-5,-8,-15,-45].each do |offset|
+            val = @seq.at(offset)
+            rep_seq = RepeatingSequence.new(@pattern)
+            val2 = rep_seq.take_back(-offset).inject(@start_value,:-)
+            val.should eq(val2)
+          end
+        end
+      end
+    end
+    
+    context 'given array of offsets' do
+      context 'not given block' do
+        it 'should return enumerator' do
+          @seq.at([1,2,3]).should be_a Enumerator
+        end
+      end
+      
+      context 'given block' do
+        it 'should yield sequence value for each offset' do
+          [ (0..@seq.pattern_size).to_a, (-@seq.pattern_size..0).to_a,
+           [-5,11,0,-33,2,15,-8] ].each do |offsets|
+            @seq.at(offsets).each_with_index do |val,i|
+              val.should eq(@seq.at(offsets[i]))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#take' do
+    context 'given negative integer' do
+      it 'should raise NegativeError' do
+        expect { @seq.take(-1) }.to raise_error(NegativeError)
+        expect { @seq.take(-10) }.to raise_error(NegativeError)
+      end
+    end
+    
+    context 'given 0' do
+      it 'should return empty array' do
+        @seq.take(0).to_a.should eq([])
+      end
+    end
+    
+    context 'given positive integer' do
+      context 'given block' do
+        it 'should yield the given number of sequence elements in forward direction (repeating as necessary)' do
+          i, m = 0, @pattern.size*2+3
+          @seq.take(m) do |n|
+            n.should eq(@seq.at(i))
+            i += 1
+          end
+          i.should eq(m)
+        end
+      end
+      
+      context 'no block given' do
+        it 'should return an enumerator' do
+          @seq.take(20).should be_a Enumerator
+        end
+      end
+    end
+  end
+  
+  describe '#take_back' do
+    context 'given negative integer' do
+      it 'should raise NegativeError' do
+        expect { @seq.take_back(-1) }.to raise_error(NegativeError)
+        expect { @seq.take_back(-10) }.to raise_error(NegativeError)
+      end
+    end
+    
+    context 'given 0' do
+      it 'should return empty array' do
+        @seq.take_back(0).to_a.should eq([])
+      end
+    end
+    
+    context 'given positive integer' do
+      context 'given block' do
+        it 'should yield the given number of pattern elements in backward direction (repeating as necessary)' do
+          i, m = 0, @pattern.size*2+3
+          @seq.take_back(m) do |n|
+            n.should eq(@seq.at(i-1))
+            i -= 1
+          end
+          (-i).should eq(m)
+        end
+      end
+      
+      context 'no block given' do
+        it 'should return an enumerator' do
+          @seq.take_back(20).should be_a Enumerator
+        end
+      end
+    end
+  end
+  
+  describe '#over' do
+    context 'given empty (invalid) range' do
+      it 'should raise EmptyError' do
+        [ 3...-2, 0...0, 5..2, -3..-5 ].each do |range|
+          expect { @seq.over(range) }.to raise_error(EmptyError)
+        end
+      end
+    end
+    
+    context 'given range over positive indices' do
+      it 'should return seq values at all offsets in range' do
+        [ 0..0, 0..2, 1...10, 4..17 ].each do |range|
+          vals = @seq.over(range).to_a
+          vals2 = range.map {|i| @seq.at(i) }
+          vals.should eq(vals2)
+        end
+      end
+    end
+    
+    context 'given negative min and/or max' do
+      it 'should return seq values at all offsets in range' do
+        [ -5..2, -10..-7, -1...1 ].each do |range|
+          vals = @seq.over(range).to_a
+          vals2 = range.map {|i| @seq.at(i) }
+          vals.should eq(vals2)
+        end
+      end
+    end
+  end
+end