musicality 0.11.1 → 0.12.0

data/spec/composition/sequencing/sequencer_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Sequencer do
+  describe '#next_part_notes' do
+    context '1 part with NoteArray sequenceable' do
+      describe 'given target duration that occurs in between note boundaries' do
+        it 'should return the part notes with the last note being shortened but tied' do
+          @seq = Sequencer.new("X" => NoteArray.new([Note.half(Pitches::G2)]))
+          expect(@seq.next_part_notes(Rational(1,4))).to eq(
+            "X" => [ Note.quarter(Pitches::G2).tie_to(Pitches::G2) ]
+          )
+        end
+      end
+    end
+
+    context '2 parts (X,Y) with NoteArray sequenceables, X twice as long as Y' do
+      before :each do
+        @x_note_array = NoteArray.new([ Note.quarter(Pitches::D3), Note.quarter(Pitches::C3),
+                          Note.quarter(Pitches::G3), Note.quarter(Pitches::F3) ])
+        @y_note_array = NoteArray.new([ Note.half(Pitches::A3) ])
+        @seq = Sequencer.new("X" => @x_note_array, "Y" => @y_note_array)
+      end
+
+      context 'target duration equal to X duration' do
+        context 'next_part_notes not called yet before' do
+          it 'should produce all the notes for X and double the notes for Y' do
+            expect(@seq.next_part_notes(@x_note_array.duration)).to eq(
+              {"X" => @x_note_array.notes, "Y" => @y_note_array.notes*2}
+            )
+          end
+        end
+
+        context 'next_part_notes already called once with target duration equal to X duration' do
+          it 'should produce all the notes for X and double the notes for Y' do
+            @seq.next_part_notes(@x_note_array.duration)
+            expect(@seq.next_part_notes(@x_note_array.duration)).to eq(
+              {"X" => @x_note_array.notes, "Y" => @y_note_array.notes*2}
+            )
+          end
+        end
+      end
+
+      context 'target duration equal to Y duration' do
+        context 'next_part_notes not called yet before' do
+          it 'should return first half of X notes and all of Y' do
+            expect(@seq.next_part_notes(Rational(@x_note_array.duration,2))).to eq(
+              { "X" => @x_note_array.notes[0..1], "Y" => @y_note_array.notes }
+            )
+          end
+        end
+
+        context 'next_part_notes already called once with half of X duration' do
+          it 'should return last half of X notes and all of Y' do
+            @seq.next_part_notes(Rational(@x_note_array.duration,2))
+            expect(@seq.next_part_notes(Rational(@x_note_array.duration,2))).to eq(
+              { "X" => @x_note_array.notes[2..3], "Y" => @y_note_array.notes }
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe '#reset' do
+    it 'should reset each sequenceable' do
+      sequencable1 = instance_double("NoteArray")
+      sequencable2 = instance_double("NoteArray")
+
+      expect(sequencable1).to receive(:reset)
+      expect(sequencable2).to receive(:reset)
+
+      seq = Sequencer.new("X" => sequencable1, "Y" => sequencable2)
+      seq.reset
+    end
+  end
+end

data/spec/composition/util/adding_sequence_spec.rb

@@ -10,65 +10,65 @@ describe AddingSequence do
       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)
+      expect(AddingSequence.new([1,2,3,4,5]).pattern_size).to 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)
+            expect(AddingSequence.new(@pattern,start_val).at(0)).to 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)
+            expect(val).to 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)
+            expect(val).to 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
+          expect(@seq.at([1,2,3])).to 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]))
+              expect(val).to eq(@seq.at(offsets[i]))
             end
           end
         end
@@ -83,33 +83,33 @@ describe AddingSequence do
         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([])
+        expect(@seq.take(0).to_a).to 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))
+            expect(n).to eq(@seq.at(i))
             i += 1
           end
-          i.should eq(m)
+          expect(i).to eq(m)
         end
       end
-      
+
       context 'no block given' do
         it 'should return an enumerator' do
-          @seq.take(20).should be_a Enumerator
+          expect(@seq.take(20)).to be_a Enumerator
         end
       end
     end
   end
-  
+
   describe '#take_back' do
     context 'given negative integer' do
       it 'should raise NegativeError' do
@@ -117,33 +117,33 @@ describe AddingSequence do
         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([])
+        expect(@seq.take_back(0).to_a).to 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))
+            expect(n).to eq(@seq.at(i-1))
             i -= 1
           end
-          (-i).should eq(m)
+          expect(-i).to eq(m)
         end
       end
-      
+
       context 'no block given' do
         it 'should return an enumerator' do
-          @seq.take_back(20).should be_a Enumerator
+          expect(@seq.take_back(20)).to be_a Enumerator
         end
       end
     end
   end
-  
+
   describe '#over' do
     context 'given empty (invalid) range' do
       it 'should raise EmptyError' do
@@ -152,23 +152,23 @@ describe AddingSequence do
         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)
+          expect(vals).to 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)
+          expect(vals).to eq(vals2)
         end
       end
     end

data/spec/composition/util/compound_sequence_spec.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe CompoundSequence do
   seqs = [ AddingSequence.new([1,1,0,2,-1]),
            RepeatingSequence.new([0,1,0,5,-13]) ]
-  
+
   describe "#at" do
     context 'given single offset' do
       [ :+, :* ].each do |sym|
@@ -14,14 +14,14 @@ describe CompoundSequence do
               vals = seqs.map {|s| s.at(offset) }
               val = vals[1..-1].inject(vals.first,sym)
               val2 = cseq.send(:at,offset)
-              val2.should eq(val)
+              expect(val2).to eq(val)
             end
           end
         end
       end
     end
   end
-  
+
   { :at => [[-5,1,33,2,0,-11], [-3,-2,-1,0,1,2,-3,-2,-1]],
     :take => [ 0, 5, 10, 13 ],
     :take_back => [ 0, 2, 6, 15 ],
@@ -34,17 +34,17 @@ describe CompoundSequence do
           it "should get values from each sequence using #{method} and combine each set of values using #{sym}" do
             args.each do |arg|
               enums = seqs.map {|s| s.send(method,arg) }
-              n = arg.is_a?(Fixnum) ? arg : arg.size
+              n = arg.is_a?(Integer) ? arg : arg.size
               vals = Array.new(n) do |i|
                 _vals = enums.map {|e| e.next }
                 _vals[1..-1].inject(_vals.first,sym)
               end
               vals2 = cseq.send(method,arg).to_a
-              vals2.should eq(vals)
+              expect(vals2).to eq(vals)
             end
           end
         end
       end
-    end    
+    end
   end
 end

data/spec/composition/util/note_generation_spec.rb

@@ -2,32 +2,32 @@ 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
+    expect(make_note(0.3,C3)).to 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])
+      expect(n.duration).to eq(0.3)
+      expect(n.pitches).to 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])
+      expect(n.duration).to eq(0.2)
+      expect(n.pitches).to 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)
+      expect(make_note(-0.3,C3).duration).to eq(0.3)
     end
-    
+
     it 'should make a rest note (no pitches)' do
-      make_note(-0.3,[C3,E3]).pitches.should be_empty
+      expect(make_note(-0.3,[C3,E3]).pitches).to be_empty
     end
   end
 end
@@ -43,71 +43,71 @@ describe 'make_notes' do
       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)
+      expect(make_notes([2,2,5],[A1,B1,C1]).size).to 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)
+      expect(@notes.size).to eq(@rhythm.size)
     end
-    
+
     it 'should follow entire rhythm once' do
-      @notes.map {|n| n.duration}.should eq(@rhythm)
+      expect(@notes.map {|n| n.duration}).to eq(@rhythm)
     end
-    
+
     it 'should cycle through pitch groups as necesary' do
-      @notes.map {|n| n.pitches}.should eq(@pitch_groups*2)
+      expect(@notes.map {|n| n.pitches}).to 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)
+      expect(@notes.size).to eq(@pitch_groups.size)
     end
-    
+
     it 'should follow entire pitch_groups once' do
-      @notes.map {|n| n.pitches}.should eq(@pitch_groups)
+      expect(@notes.map {|n| n.pitches}).to eq(@pitch_groups)
     end
-    
+
     it 'should cycle through rhythm as necesary' do
-      @notes.map {|n| n.duration}.should eq(@rhythm*2)
+      expect(@notes.map {|n| n.duration}).to 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)
+      expect(@notes.size).to eq(@pitch_groups.size)
+      expect(@notes.size).to eq(@rhythm.size)
     end
-    
+
     it 'should follow entire rhythm once' do
-      @notes.map {|n| n.pitches}.should eq(@pitch_groups)
+      expect(@notes.map {|n| n.pitches}).to eq(@pitch_groups)
     end
-    
+
     it 'should follow entire pitch groups once' do
-      @notes.map {|n| n.duration}.should eq(@rhythm)
+      expect(@notes.map {|n| n.duration}).to eq(@rhythm)
     end
   end
 end

data/spec/composition/util/probabilities_spec.rb

@@ -9,29 +9,29 @@ describe Probabilities do
         (1..10).step(2) do |n|
           5.times do
             x = Probabilities.send(class_method,n)
-            x.size.should eq(n)
-            x.inject(0,:+).should eq(1)
+            expect(x.size).to eq(n)
+            expect(x.inject(0,:+)).to eq(1)
           end
         end
       end
     end
   end
-  
+
   describe '.random' do
     it 'should return array of all-different values' do
       x = Probabilities.random(100)
-      Set.new(x).size.should eq(100)
+      expect(Set.new(x).size).to eq(100)
     end
   end
-  
+
   describe '.uniform' do
     it 'should return array of all (or all-but-one) same values' do
       [2,6,10,33,78,100].each do |n|
         x = Probabilities.uniform(n)
         y = Set.new(x)
-        (y.size == 1 || y.size == 2).should eq(true)
+        expect(y.size == 1 || y.size == 2).to eq(true)
         if y.size == 2
-          y.entries[0].should be_within(1e-9).of(y.entries[1])
+          expect(y.entries[0]).to be_within(1e-9).of(y.entries[1])
         end
       end
     end

data/spec/composition/util/random_sampler_spec.rb

@@ -28,17 +28,17 @@ describe RandomSampler do
           sampler.values.each_with_index do |val,i|
             count = counts[val]
             tgt_prob = sampler.probabilities[i]
-            (count / 1000.to_f).should be_within(0.1).of(tgt_prob)
+            expect(count / 1000.to_f).to be_within(0.1).of(tgt_prob)
           end
         end
       end
     end
-    
+
     context 'given number of samples to take' do
       it 'should return array with the given number of samples' do
         @samplers.each do |sampler|
           [1,2,5,10].each do |n|
-            sampler.sample(n).size.should eq(n)
+            expect(sampler.sample(n).size).to eq(n)
           end
         end
       end

data/spec/composition/util/repeating_sequence_spec.rb

@@ -10,41 +10,41 @@ describe RepeatingSequence do
       end
     end
   end
-  
+
   describe '#pattern_size' do
     it 'should return the pattern size' do
-      RepeatingSequence.new([1,2,3,4,5]).pattern_size.should eq(5)
+      expect(RepeatingSequence.new([1,2,3,4,5]).pattern_size).to eq(5)
     end
   end
-  
+
   before :all do
     @pattern = [2,1,5,4,3]
     @seq = RepeatingSequence.new(@pattern)
   end
-  
+
   describe '#at' do
     context 'given single offset' do
       it 'should module index into pattern using given offset' do
         n = @pattern.size
         (0..n*2).each do |i|
-          @seq.at(i).should eq(@pattern[i%n])
+          expect(@seq.at(i)).to eq(@pattern[i%n])
         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
+          expect(@seq.at([1,2,3])).to 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]))
+              expect(val).to eq(@seq.at(offsets[i]))
             end
           end
         end
@@ -59,32 +59,32 @@ describe RepeatingSequence do
         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([])
+        expect(@seq.take(0).to_a).to eq([])
       end
     end
-    
+
     context 'given positive integer' do
       context 'given block' do
         it 'should yield the given number of pattern elements in forward direction (repeating as necessary)' do
           i = 0
           @seq.take(@pattern.size*2+3) do |n|
-            n.should eq(@seq.at(i))
+            expect(n).to eq(@seq.at(i))
             i += 1
           end
         end
       end
-      
+
       context 'no block given' do
         it 'should return an enumerator' do
-          @seq.take(20).should be_a Enumerator
+          expect(@seq.take(20)).to be_a Enumerator
         end
       end
     end
   end
-  
+
   describe '#take_back' do
     context 'given negative integer' do
       it 'should raise NegativeError' do
@@ -92,33 +92,33 @@ describe RepeatingSequence do
         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([])
+        expect(@seq.take_back(0).to_a).to 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))
+            expect(n).to eq(@seq.at(i-1))
             i -= 1
           end
-          (-i).should eq(m)
+          expect(-i).to eq(m)
         end
       end
-      
+
       context 'no block given' do
         it 'should return an enumerator' do
-          @seq.take_back(20).should be_a Enumerator
+          expect(@seq.take_back(20)).to be_a Enumerator
         end
       end
     end
   end
-  
+
   describe '#over' do
     context 'given empty (invalid) range' do
       it 'should raise EmptyError' do
@@ -127,23 +127,23 @@ describe RepeatingSequence do
         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)
+          expect(vals).to 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)
+          expect(vals).to eq(vals2)
         end
       end
     end

data/spec/musicality_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe Musicality do
   it "should have a VERSION constant" do
-    subject.const_get('VERSION').should_not be_empty
+    expect(subject.const_get('VERSION')).to_not be_empty
   end
 end