mtk 0.0.2 → 0.0.3

data/spec/mtk/patterns/chain_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe MTK::Patterns::Chain do
+
+  CHAIN = MTK::Patterns::Chain
+
+  describe '#next' do
+    it 'combines 2 basic attributes together' do
+      chain = CHAIN.new [C,q]
+      chain.next.should == [C,q]
+    end
+
+    it 'combines 3 basic attributes together' do
+      chain = CHAIN.new [C,q,mp]
+      chain.next.should == [C,q,mp]
+    end
+
+    it 'combines many basic attributes together, including duplicate types' do
+      chain = CHAIN.new [C,q,D,h,s,mp,fff]
+      chain.next.should == [C,q,D,h,s,mp,fff]
+    end
+
+    it 'raises StopIteration after a basic-attribute-only chain has called #next more than once' do
+      chain = CHAIN.new [C,q]
+      chain.next
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines a basic attribute with a pattern' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E), q]
+      chain.next.should == [C,q]
+      chain.next.should == [D,q]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines 2 patterns' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E), Patterns.Sequence(w,h,q)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines 2 patterns, and returns #next until the last StopIteration of a nested Pattern occurs' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E), Patterns.Sequence(w,h,q,i)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      chain.next.should == [C,i]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+
+    # TODO: more than 2 patterns, and more than 2 + basic attribute(s)
+
+
+    it 'combines Choice patterns with max_cycles' do
+      chain = CHAIN.new [Patterns.Choice(i,s), Patterns.Choice(C,D,E)], max_cycles:100
+      100.times do |time|
+        attrs = chain.next
+        attrs.length.should == 2
+        (attrs[0]==i or attrs[0]==s).should be_true
+        (attrs[1]==C or attrs[1]==D or attrs[1]==E).should be_true
+      end
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'combines Choice patterns and emits a only single combination of attributes by default' do
+      chain = CHAIN.new [Patterns.Choice(i,s), Patterns.Choice(C,D,E)]
+      chain.next
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'flattens attribute lists with nested chains' do
+      chain = CHAIN.new( [1, 2, CHAIN.new([3, CHAIN.new([4,5])])] )
+      chain.next.should == [1,2,3,4,5]
+    end
+
+    it 'throws StopIteration when any subpattern throws StopIteration with max_elements_exceeded' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E,F,G), Patterns.Sequence(w,h,q,i,  max_elements:3)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+
+    it 'throws StopIteration with max_elements_exceeded (edge case actual element length == max_elements)' do
+      chain = CHAIN.new [Patterns.Sequence(C,D,E,F,G), Patterns.Sequence(w,h,q,  max_elements:3)]
+      chain.next.should == [C,w]
+      chain.next.should == [D,h]
+      chain.next.should == [E,q]
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+  end
+
+  describe '#rewind' do
+    it 'resets the state of the Chain' do
+      # compare with the #next, raises StopIteration test above
+      chain = CHAIN.new [C,q]
+      chain.next
+      chain.rewind
+      lambda{ chain.next }.should_not raise_error StopIteration
+      lambda{ chain.next }.should raise_error StopIteration
+    end
+  end
+
+  # TODO: test the chain builder method in Patterns module
+
+end

data/spec/mtk/{pattern → patterns}/choice_spec.rb

@@ -1,14 +1,20 @@
 require 'spec_helper'
 require 'set'
 
-describe MTK::Pattern::Choice do
+describe MTK::Patterns::Choice do
 
-  CHOICE = MTK::Pattern::Choice
+  CHOICE = MTK::Patterns::Choice
 
   let(:elements) { [1,2,3] }
-  let(:choice) { CHOICE.new elements }
+  let(:choice) { CHOICE.new elements, max_cycles:500 }
 
   describe "#next" do
+    it "throws StopIteration on the second call to #next, by default" do
+      choice = CHOICE.new elements
+      choice.next
+      lambda{ choice.next }.should raise_error StopIteration
+    end
+
     it "randomly chooses one of the elements" do
       choosen = Set.new
       100.times do
@@ -19,7 +25,7 @@ describe MTK::Pattern::Choice do
     end
 
     it "does a weighted random selection when a weights list is passed in via constructor options[:weights]" do
-      choice = CHOICE.new elements, :weights => [1,3,0] # only choose first 2 elements, and choose the second three times as often
+      choice = CHOICE.new elements, max_cycles:100, weights:[1,3,0] # only choose first 2 elements, and choose the second three times as often
       choosen = Set.new
       first_count, second_count = 0,0
       100.times do
@@ -33,7 +39,7 @@ describe MTK::Pattern::Choice do
     end
 
     it "enumerates a choosen sub-sequence" do
-      choice = CHOICE.new [MTK::Pattern.Sequence(4,5,6)]
+      choice = CHOICE.new [MTK::Patterns.Sequence(4,5,6)], max_cycles:10
       choice.next.should == 4
       choice.next.should == 5
       choice.next.should == 6
@@ -46,61 +52,45 @@ describe MTK::Pattern::Choice do
 end
 
 
-describe MTK::Pattern do
+describe MTK::Patterns do
 
   describe "#Choice" do
     it "creates a Choice" do
-      MTK::Pattern.Choice(1,2,3).should be_a MTK::Pattern::Choice
+      MTK::Patterns.Choice(1,2,3).should be_a MTK::Patterns::Choice
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.Choice(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "does not set a type" do
-      MTK::Pattern.Choice(1,2,3).type.should be_nil
+      MTK::Patterns.Choice(1,2,3).elements.should == [1,2,3]
     end
   end
 
   describe "#PitchChoice" do
     it "creates a Choice" do
-      MTK::Pattern.PitchChoice(1,2,3).should be_a MTK::Pattern::Choice
+      MTK::Patterns.PitchChoice(1,2,3).should be_a MTK::Patterns::Choice
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.PitchChoice(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "sets #type to :pitch" do
-      MTK::Pattern.PitchChoice([]).type.should == :pitch
+      MTK::Patterns.PitchChoice(1,2,3).elements.should == [Pitch(1),Pitch(2),Pitch(3)]
     end
   end
 
   describe "#IntensityChoice" do
     it "creates a Choice" do
-      MTK::Pattern.IntensityChoice(1,2,3).should be_a MTK::Pattern::Choice
+      MTK::Patterns.IntensityChoice(1,2,3).should be_a MTK::Patterns::Choice
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.IntensityChoice(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "sets #type to :pitch" do
-      MTK::Pattern.IntensityChoice([]).type.should == :intensity
+      MTK::Patterns.IntensityChoice(1,2,3).elements.should == [Intensity(1),Intensity(2),Intensity(3)]
     end
   end
 
   describe "#DurationChoice" do
     it "creates a Choice" do
-      MTK::Pattern.DurationChoice(1,2,3).should be_a MTK::Pattern::Choice
+      MTK::Patterns.DurationChoice(1,2,3).should be_a MTK::Patterns::Choice
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.DurationChoice(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "sets #type to :pitch" do
-      MTK::Pattern.DurationChoice([]).type.should == :duration
+      MTK::Patterns.DurationChoice(1,2,3).elements.should == [q,h,h+q]
     end
   end
 

data/spec/mtk/{pattern → patterns}/cycle_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe MTK::Pattern::Cycle do
+describe MTK::Patterns::Cycle do
 
-  CYCLE = MTK::Pattern::Cycle
+  CYCLE = MTK::Patterns::Cycle
 
   let(:elements) { [1, 2, 3] }
   let(:cycle) { CYCLE.new elements }
@@ -22,14 +22,14 @@ describe MTK::Pattern::Cycle do
     end
 
     it "enumerates nested sequences" do
-      cycle = CYCLE.new [1, MTK::Pattern.Sequence(2,3), 4]
+      cycle = CYCLE.new [1, MTK::Patterns.Sequence(2,3), 4]
       nexts = []
       6.times { nexts << cycle.next }
       nexts.should == [1,2,3,4,1,2]
     end
   end
 
-  describe "#max_cycles" do
+  describe "@max_cycles" do
     it "is the :max_cycles option the pattern was constructed with" do
       CYCLE.new([], :max_cycles => 1).max_cycles.should == 1
     end
@@ -38,6 +38,10 @@ describe MTK::Pattern::Cycle do
       cycle.max_cycles.should be_nil
     end
 
+    it "loops indefinitely when it's nil" do
+      lambda { 100.times { cycle.next } }.should_not raise_error
+    end
+
     it "causes a StopIteration exception after the number of cycles has completed" do
       cycle = CYCLE.new(elements, :max_cycles => 2)
       2.times do
@@ -45,17 +49,19 @@ describe MTK::Pattern::Cycle do
       end
       lambda { cycle.next }.should raise_error
     end
+  end
 
-    it "is maintained when applying Collection operations" do
-      CYCLE.new(elements, :max_cycles => 2).reverse.max_cycles.should == 2
+  describe "@max_elements" do
+    it "causes a StopIteration exception after the number of elements have been emitted, with a higher max_cycles" do
+      cycle = CYCLE.new(elements, max_cycles:2, max_elements:5)
+      5.times { cycle.next }
+      lambda { cycle.next }.should raise_error StopIteration
     end
-  end
 
-  describe "#max_elements" do
     it "causes a StopIteration exception after the number of elements have been emitted" do
-      cycle = CYCLE.new(elements, :max_elements => 5)
+      cycle = CYCLE.new(elements, max_elements:5)
       5.times { cycle.next }
-      lambda { cycle.next }.should raise_error
+      lambda { cycle.next }.should raise_error StopIteration
     end
   end
 
@@ -72,61 +78,45 @@ describe MTK::Pattern::Cycle do
 end
 
 
-describe MTK::Pattern do
+describe MTK::Patterns do
 
   describe "#Cycle" do
     it "creates a Cycle" do
-      MTK::Pattern.Cycle(1,2,3).should be_a MTK::Pattern::Cycle
+      MTK::Patterns.Cycle(1,2,3).should be_a MTK::Patterns::Cycle
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.Cycle(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "does not set a type" do
-      MTK::Pattern.Cycle(1,2,3).type.should be_nil
+      MTK::Patterns.Cycle(1,2,3).elements.should == [1,2,3]
     end
   end
 
   describe "#PitchCycle" do
     it "creates a Cycle" do
-      MTK::Pattern.PitchCycle(1,2,3).should be_a MTK::Pattern::Cycle
+      MTK::Patterns.PitchCycle(1,2,3).should be_a MTK::Patterns::Cycle
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.PitchCycle(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "sets #type to :pitch" do
-      MTK::Pattern.PitchCycle([]).type.should == :pitch
+      MTK::Patterns.PitchCycle(1,2,3).elements.should == [Pitch(1),Pitch(2),Pitch(3)]
     end
   end
 
   describe "#IntensityCycle" do
     it "creates a Cycle" do
-      MTK::Pattern.IntensityCycle(1,2,3).should be_a MTK::Pattern::Cycle
+      MTK::Patterns.IntensityCycle(1,2,3).should be_a MTK::Patterns::Cycle
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.IntensityCycle(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "sets #type to :pitch" do
-      MTK::Pattern.IntensityCycle([]).type.should == :intensity
+      MTK::Patterns.IntensityCycle(1,2,3).elements.should == [Intensity(1),Intensity(2),Intensity(3)]
     end
   end
 
   describe "#DurationCycle" do
     it "creates a Cycle" do
-      MTK::Pattern.DurationCycle(1,2,3).should be_a MTK::Pattern::Cycle
+      MTK::Patterns.DurationCycle(1,2,3).should be_a MTK::Patterns::Cycle
     end
 
     it "sets #elements from the varargs" do
-      MTK::Pattern.DurationCycle(1,2,3).elements.should == [1,2,3]
-    end
-
-    it "sets #type to :pitch" do
-      MTK::Pattern.DurationCycle([]).type.should == :duration
+      MTK::Patterns.DurationCycle(1,2,3).elements.should == [Duration(1),Duration(2),Duration(3)]
     end
   end
 

data/spec/mtk/patterns/for_each_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe MTK::Patterns::ForEach do
+
+  FOREACH = ::MTK::Patterns::ForEach
+
+  def var(name)
+    ::MTK::Variable.new(name)
+  end
+
+  def seq(*args)
+    ::MTK::Patterns.Sequence(*args)
+  end
+
+  def chain(*args)
+    ::MTK::Patterns.Chain(*args)
+  end
+
+
+  describe "#elements" do
+    it "is the array the sequence was constructed with" do
+      FOREACH.new([seq(1,2),seq(3,4)]).elements.should == [seq(1,2),seq(3,4)]
+    end
+  end
+
+  describe "#next" do
+    it "enumerates each element in the second pattern for each element in the first, with variable '$' as the first pattern's current element" do
+      foreach = FOREACH.new [ seq(C,D,E), seq(var('$'),G,A) ]
+      vals = []
+      9.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [C,G,A,D,G,A,E,G,A]
+    end
+
+    it "enumerates the foreach construct with a variable in the middle of the second pattern" do
+      foreach = FOREACH.new [ seq(C,D,E), seq(G,var('$'),A) ]
+      vals = []
+      9.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [G,C,A,G,D,A,G,E,A]
+    end
+
+    it "enumerates the foreach construct with multiple variables" do
+      foreach = FOREACH.new [ seq(C,D,E), seq(G,var('$'),A,var('$')) ]
+      vals = []
+      12.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [G,C,A,C,G,D,A,D,G,E,A,E]
+    end
+
+    it "handles 3-level nesting" do
+      foreach = FOREACH.new [ seq(C,D), seq(var('$'),F), seq(G,var('$')) ]
+      vals = []
+      8.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [G,C,G,F,G,D,G,F]
+    end
+
+    it "handles 4-level nesting" do
+      foreach = FOREACH.new [ seq(C,D), seq(var('$'),E), seq(F,var('$')), seq(var('$'),G) ]
+      vals = []
+      16.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [F,G,C,G,F,G,E,G,F,G,D,G,F,G,E,G]
+    end
+
+    it "evaluates the '$$' var by going back 2 levels in the variables stack" do
+      foreach = FOREACH.new [ seq(C,D), seq(E,F), seq(var('$$'),var('$')) ]
+      vals = []
+      8.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [C,E,C,F,D,E,D,F]
+    end
+
+
+    it "evaluates the '$$$' var by going back 3 levels in the variables stack" do
+      foreach = FOREACH.new [ seq(C,D), seq(E,F), seq(G,A), seq(var('$$$'),var('$$'),var('$')) ]
+      vals = []
+      24.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [C,E,G,C,E,A,C,F,G,C,F,A,D,E,G,D,E,A,D,F,G,D,F,A]
+    end
+
+    it "evaluates nested variables" do
+      # (C4 Bb Ab G)@( (C D C $):(q i i)*4:(mp mf) )
+      foreach = FOREACH.new( [seq(G,A), chain(seq(C,D,var('$')),seq(q,i,s))] )
+      vals = []
+      6.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should == [[C,q],[D,i],[G,s],[C,q],[D,i],[A,s]]
+    end
+
+  end
+
+
+
+  describe "#rewind" do
+    it "restarts at the beginning of the sequence" do
+      foreach = FOREACH.new [ seq(C,D,E), seq(var('$'),G,A) ]
+      6.times{ foreach.next }
+      foreach.next.should == E
+      foreach.rewind
+      vals = []
+      9.times{ vals << foreach.next }
+      lambda{ foreach.next }.should raise_error StopIteration
+      vals.should ==  [C,G,A,D,G,A,E,G,A]
+    end
+
+    it "returns self, so it can be chained to #next" do
+      foreach = FOREACH.new [ seq(C,D,E), seq(var('$'),G,A) ]
+      first = foreach.next
+      foreach.rewind.next.should == first
+      foreach.rewind.next.should == first
+    end
+  end
+
+end
+
+
+describe MTK::Patterns do
+
+  def seq(*args)
+    ::MTK::Patterns.Sequence(*args)
+  end
+
+  describe "#ForEach" do
+    it "creates a Sequence" do
+      MTK::Patterns.ForEach(seq(1,2),seq(3,4)).should be_a MTK::Patterns::ForEach
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.ForEach(seq(1,2),seq(3,4)).elements.should == [seq(1,2),seq(3,4)]
+    end
+  end
+
+end