jmtk 0.0.3.3-java

data/spec/mtk/patterns/cycle_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe MTK::Patterns::Cycle do
+
+  CYCLE = MTK::Patterns::Cycle
+
+  let(:elements) { [1, 2, 3] }
+  let(:cycle) { CYCLE.new elements }
+
+  describe "#next" do
+    it "iterates through the list of elements and emits them one at a time" do
+      cycle.next.should == elements[0]
+      cycle.next.should == elements[1]
+      cycle.next.should == elements[2]
+    end
+
+    it "starts at the beginning of the list of elements after the end of the list is reached" do
+      elements.length.times do
+        cycle.next
+      end
+      cycle.next.should == elements.first
+    end
+
+    it "enumerates nested sequences" do
+      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
+    it "is the :max_cycles option the pattern was constructed with" do
+      CYCLE.new([], :max_cycles => 1).max_cycles.should == 1
+    end
+
+    it "is nil by default" 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
+        elements.length.times { cycle.next } # one full cycle
+      end
+      lambda { cycle.next }.should raise_error
+    end
+  end
+
+  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
+
+    it "causes a StopIteration exception after the number of elements have been emitted" do
+      cycle = CYCLE.new(elements, max_elements:5)
+      5.times { cycle.next }
+      lambda { cycle.next }.should raise_error StopIteration
+    end
+  end
+
+  describe "#rewind" do
+    it "restarts the cycle" do
+      (elements.length - 1).times do
+        cycle.next
+      end
+      cycle.rewind
+      cycle.next.should == elements.first
+    end
+  end
+
+end
+
+
+describe MTK::Patterns do
+
+  describe "#Cycle" do
+    it "creates a Cycle" do
+      MTK::Patterns.Cycle(1,2,3).should be_a MTK::Patterns::Cycle
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.Cycle(1,2,3).elements.should == [1,2,3]
+    end
+  end
+
+  describe "#PitchCycle" do
+    it "creates a Cycle" do
+      MTK::Patterns.PitchCycle(1,2,3).should be_a MTK::Patterns::Cycle
+    end
+
+    it "sets #elements from the varargs" do
+      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::Patterns.IntensityCycle(1,2,3).should be_a MTK::Patterns::Cycle
+    end
+
+    it "sets #elements from the varargs" do
+      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::Patterns.DurationCycle(1,2,3).should be_a MTK::Patterns::Cycle
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.DurationCycle(1,2,3).elements.should == [Duration(1),Duration(2),Duration(3)]
+    end
+  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::Lang::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

data/spec/mtk/patterns/function_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe MTK::Patterns::Function do
+
+  FUNCTION = MTK::Patterns::Function
+
+  describe "#next" do
+    it "calls a lambda to produce elements" do
+      function = FUNCTION.new lambda{ 1 + 1 }
+      function.next.should == 2
+      function.next.should == 2
+    end
+
+    it "calls a 1-arg lambda with the previous value" do
+      function = FUNCTION.new lambda{|prev| (prev || 0) + 1 }
+      function.next.should == 1
+      function.next.should == 2
+      function.next.should == 3
+    end
+
+    it "stops looping when the lambda raises StopIteration" do
+      function = FUNCTION.new lambda{|prev| raise StopIteration if prev == 2; (prev || 0) + 1 }
+      nexts = []
+      loop do
+        nexts << function.next
+      end
+      nexts.should == [1,2]
+    end
+
+    it "calls a 2-arg lambda with the previous value and function call count (starting from 0)" do
+      function = FUNCTION.new lambda{|prev,index| [prev,index] }
+      function.next.should == [nil, 0]
+      function.next.should == [[nil,0], 1]
+      function.next.should == [[[nil,0],1], 2]
+    end
+
+    it "calls a 3-arg lambda with the previous value, function call count (starting from 0), and element count (starting from 0)" do
+      function = FUNCTION.new lambda{|prev,call_index,elem_index| prev.nil? ? MTK::Patterns.Sequence(1,2,3,4) : [call_index,elem_index] }
+      function.next.should == 1
+      function.next.should == 2
+      function.next.should == 3
+      function.next.should == 4
+      function.next.should == [1,4]
+    end
+
+    it "can generate other Patterns, which will be iterated over before re-calling the function" do
+      function = FUNCTION.new lambda{|prev,index| MTK::Patterns.Sequence(index,2,3) }
+      function.next.should == 0
+      function.next.should == 2
+      function.next.should == 3
+      function.next.should == 1 # end of sequence, now a new one is generated, this time starting with 1
+      function.next.should == 2
+      function.next.should == 3
+    end
+  end
+
+  describe "#rewind" do
+    it "resets previous value and element count" do
+      function = FUNCTION.new lambda{|prev,index| [prev,index] }
+      function.next.should == [nil, 0]
+      function.next.should == [[nil,0], 1]
+      function.rewind
+      function.next.should == [nil, 0]
+    end
+  end
+
+end
+
+
+describe MTK::Patterns do
+
+  let(:mock_lambda) { lambda{|_|:mock_value} }
+
+  describe "#Function" do
+    it "creates a Function" do
+      MTK::Patterns.Function(nil).should be_a MTK::Patterns::Function
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.Function(:mock_lambda).function.should == :mock_lambda
+    end
+
+    it "doesn't wrap a lambda in the varargs Array" do
+      function = MTK::Patterns.Function( lambda{ 1 + 1 } )
+      function.next.should == 2
+    end
+  end
+
+  describe "#PitchFunction" do
+    it "creates a Function" do
+      MTK::Patterns.PitchFunction(mock_lambda).should be_a MTK::Patterns::Function
+    end
+
+    it "sets #elements from the varargs" do
+      func = mock_lambda
+      MTK::Patterns.PitchFunction(func).function.should == func
+    end
+  end
+
+  describe "#IntensityFunction" do
+    it "creates a Function" do
+      MTK::Patterns.IntensityFunction(mock_lambda).should be_a MTK::Patterns::Function
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.IntensityFunction(mock_lambda).function.should == mock_lambda
+    end
+  end
+
+  describe "#DurationFunction" do
+    it "creates a Function" do
+      MTK::Patterns.DurationFunction(mock_lambda).should be_a MTK::Patterns::Function
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.DurationFunction(mock_lambda).function.should == mock_lambda
+    end
+  end
+
+end

data/spec/mtk/patterns/lines_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe MTK::Patterns::Lines do
+
+  LINES = MTK::Patterns::Lines
+
+  let(:elements) { [0, [10,5], [5,10]] }
+  let(:lines) { LINES.new elements }
+
+  describe "#next" do
+    it "interpolates between values, treating each element as [value, steps_to_value] pairs" do
+      nexts = []
+      loop do
+        nexts << lines.next
+      end
+      nexts.should == [0, 2,4,6,8,10, 9.5,9,8.5,8,7.5,7,6.5,6,5.5,5]
+    end
+  end
+
+  describe "#rewind" do
+    it "starts the pattern from the beginning" do
+      10.times { lines.next }
+      lines.rewind
+      nexts = []
+      loop do
+        nexts << lines.next
+      end
+      nexts.should == [0, 2,4,6,8,10, 9.5,9,8.5,8,7.5,7,6.5,6,5.5,5]
+    end
+  end
+
+end
+
+
+describe MTK::Patterns do
+
+  describe "#Lines" do
+    it "creates a Lines" do
+      MTK::Patterns.Lines(1,2,3).should be_a MTK::Patterns::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.Lines(1,2,3).elements.should == [1,2,3]
+    end
+  end
+
+  describe "#PitchLines" do
+    it "creates a Lines" do
+      MTK::Patterns.PitchLines(1,2,3).should be_a MTK::Patterns::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.PitchLines(1,2,3).elements.should == [Pitch(1),Pitch(2),Pitch(3)]
+    end
+  end
+
+  describe "#IntensityLines" do
+    it "creates a Lines" do
+      MTK::Patterns.IntensityLines(1,2,3).should be_a MTK::Patterns::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.IntensityLines(1,2,3).elements.should == [Intensity(1),Intensity(2),Intensity(3)]
+    end
+  end
+
+  describe "#DurationLines" do
+    it "creates a Lines" do
+      MTK::Patterns.DurationLines(1,2,3).should be_a MTK::Patterns::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Patterns.DurationLines(1,2,3).elements.should == [Duration(1),Duration(2),Duration(3)]
+    end
+  end
+
+end