mtk 0.0.1 → 0.0.2

data/spec/mtk/pattern/abstract_pattern_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe MTK::Pattern::AbstractPattern do
+
+  PATTERN = MTK::Pattern::AbstractPattern
+
+  let(:elements) { [1,2,3] }
+
+  describe "#type" do
+    it "is the :type value from the constuctor's options hash" do
+      PATTERN.new([], :type => :my_type).type.should == :my_type
+    end
+  end
+
+  describe "#max_elements" do
+    it "is the :max_elements option the pattern was constructed with" do
+      PATTERN.new([], :max_elements => 1).max_elements.should == 1
+    end
+
+    it "is nil by default" do
+      PATTERN.new([]).max_elements.should be_nil
+    end
+
+    it "causes a StopIteration exception after the number of elements have been emitted" do
+      cycle = PATTERN.new([:anything], :max_elements => 5)
+      5.times { cycle.next }
+      lambda { cycle.next }.should raise_error
+    end
+  end
+
+  describe "#==" do
+    it "is true if the elements and types are equal" do
+      PATTERN.new(elements, :type => :some_type).should == PATTERN.new(elements, :type => :some_type)
+    end
+
+    it "is false if the elements are not equal" do
+      PATTERN.new(elements, :type => :some_type).should_not == PATTERN.new(elements + [4], :type => :some_type)
+    end
+
+    it "is false if the types are not equal" do
+      PATTERN.new(elements, :type => :some_type).should_not == PATTERN.new(elements, :type => :another_type)
+    end
+  end
+
+end

data/spec/mtk/pattern/choice_spec.rb

@@ -3,8 +3,10 @@ require 'set'
 
 describe MTK::Pattern::Choice do
 
+  CHOICE = MTK::Pattern::Choice
+
   let(:elements) { [1,2,3] }
-  let(:choice) { Pattern::Choice.new elements }
+  let(:choice) { CHOICE.new elements }
 
   describe "#next" do
     it "randomly chooses one of the elements" do
@@ -12,10 +14,94 @@ describe MTK::Pattern::Choice do
       100.times do
         element = choice.next
         choosen << element
-        elements.should include(element)
       end
-      choosen.to_a.sort.should == elements
+      choosen.to_a.should =~ elements
+    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
+      choosen = Set.new
+      first_count, second_count = 0,0
+      100.times do
+        element = choice.next
+        choosen << element
+        first_count += 1 if element == elements[0]
+        second_count += 1 if element == elements[1]
+      end
+      choosen.to_a.should =~ elements[0..1]
+      (first_count + 10).should < second_count # this may occasional fail, but it seems unlikely
+    end
+
+    it "enumerates a choosen sub-sequence" do
+      choice = CHOICE.new [MTK::Pattern.Sequence(4,5,6)]
+      choice.next.should == 4
+      choice.next.should == 5
+      choice.next.should == 6
+      choice.next.should == 4 # now it will select a new choice, but there's only one, so it will be the same
+      choice.next.should == 5
+      choice.next.should == 6
     end
   end
 
 end
+
+
+describe MTK::Pattern do
+
+  describe "#Choice" do
+    it "creates a Choice" do
+      MTK::Pattern.Choice(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+  describe "#PitchChoice" do
+    it "creates a Choice" do
+      MTK::Pattern.PitchChoice(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+  describe "#IntensityChoice" do
+    it "creates a Choice" do
+      MTK::Pattern.IntensityChoice(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+  describe "#DurationChoice" do
+    it "creates a Choice" do
+      MTK::Pattern.DurationChoice(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+end

data/spec/mtk/pattern/cycle_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe MTK::Pattern::Cycle do
+
+  CYCLE = MTK::Pattern::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::Pattern.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 "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
+
+    it "is maintained when applying Collection operations" do
+      CYCLE.new(elements, :max_cycles => 2).reverse.max_cycles.should == 2
+    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)
+      5.times { cycle.next }
+      lambda { cycle.next }.should raise_error
+    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::Pattern do
+
+  describe "#Cycle" do
+    it "creates a Cycle" do
+      MTK::Pattern.Cycle(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+  describe "#PitchCycle" do
+    it "creates a Cycle" do
+      MTK::Pattern.PitchCycle(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+  describe "#IntensityCycle" do
+    it "creates a Cycle" do
+      MTK::Pattern.IntensityCycle(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+  describe "#DurationCycle" do
+    it "creates a Cycle" do
+      MTK::Pattern.DurationCycle(1,2,3).should be_a MTK::Pattern::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
+    end
+  end
+
+end

data/spec/mtk/pattern/function_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe MTK::Pattern::Function do
+
+  FUNCTION = MTK::Pattern::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::Pattern.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::Pattern.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::Pattern do
+
+  describe "#Function" do
+    it "creates a Function" do
+      MTK::Pattern.Function(nil).should be_a MTK::Pattern::Function
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.Function(:mock_lambda).function.should == :mock_lambda
+    end
+
+    it "does not set a type" do
+      MTK::Pattern.Function(:mock_lambda).type.should be_nil
+    end
+
+    it "doesn't wrap a lambda in the varargs Array" do
+      function = MTK::Pattern.Function( lambda{ 1 + 1 } )
+      function.next.should == 2
+    end
+  end
+
+  describe "#PitchFunction" do
+    it "creates a Function" do
+      MTK::Pattern.PitchFunction(:mock_lambda).should be_a MTK::Pattern::Function
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.PitchFunction(:mock_lambda).function.should == :mock_lambda
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.PitchFunction([]).type.should == :pitch
+    end
+  end
+
+  describe "#IntensityFunction" do
+    it "creates a Function" do
+      MTK::Pattern.IntensityFunction(:mock_lambda).should be_a MTK::Pattern::Function
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.IntensityFunction(:mock_lambda).function.should == :mock_lambda
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.IntensityFunction([]).type.should == :intensity
+    end
+  end
+
+  describe "#DurationFunction" do
+    it "creates a Function" do
+      MTK::Pattern.DurationFunction(:mock_lambda).should be_a MTK::Pattern::Function
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.DurationFunction(:mock_lambda).function.should == :mock_lambda
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.DurationFunction([]).type.should == :duration
+    end
+  end
+
+end

data/spec/mtk/pattern/lines_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe MTK::Pattern::Lines do
+
+  LINES = MTK::Pattern::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::Pattern do
+
+  describe "#Lines" do
+    it "creates a Lines" do
+      MTK::Pattern.Lines(1,2,3).should be_a MTK::Pattern::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.Lines(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "does not set a type" do
+      MTK::Pattern.Lines(1,2,3).type.should be_nil
+    end
+  end
+
+  describe "#PitchLines" do
+    it "creates a Lines" do
+      MTK::Pattern.PitchLines(1,2,3).should be_a MTK::Pattern::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.PitchLines(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.PitchLines([]).type.should == :pitch
+    end
+  end
+
+  describe "#IntensityLines" do
+    it "creates a Lines" do
+      MTK::Pattern.IntensityLines(1,2,3).should be_a MTK::Pattern::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.IntensityLines(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.IntensityLines([]).type.should == :intensity
+    end
+  end
+
+  describe "#DurationLines" do
+    it "creates a Lines" do
+      MTK::Pattern.DurationLines(1,2,3).should be_a MTK::Pattern::Lines
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.DurationLines(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.DurationLines([]).type.should == :duration
+    end
+  end
+
+end

data/spec/mtk/pattern/note_cycle_spec.rb.bak

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe MTK::Pattern::NoteCycle do
+
+  def note(pitch, intensity=mf, duration=1)
+    Note(pitch, intensity, duration)
+  end
+
+  describe "#new" do
+    it "allows default pitch to be specified" do
+      cycle = Pattern::NoteCycle.new [], [p], [1], :pitch => Gb4
+      cycle.next.should == Note(Gb4, p, 1)
+    end
+    it "allows default intensity to be specified" do
+      cycle = Pattern::NoteCycle.new [C4], [], [1], :intensity => ppp
+      cycle.next.should == Note(C4, ppp, 1)
+    end
+    it "allows default duration to be specified" do
+      cycle = Pattern::NoteCycle.new [C4], [mf], [], :duration => 12
+      cycle.next.should == Note(C4, mf, 12)
+    end
+  end
+
+  describe "#next" do
+    it "iterates through the pitch, intensity, and duration list in parallel to emit Notes" do
+      cycle = Pattern::NoteCycle.new [C4, D4, E4], [p, f], [1,2,3,4]
+      cycle.next.should == Note(C4, p, 1)
+      cycle.next.should == Note(D4, f, 2)
+      cycle.next.should == Note(E4, p, 3)
+      cycle.next.should == Note(C4, f, 4)
+      cycle.next.should == Note(D4, p, 1)
+      cycle.next.should == Note(E4, f, 2)
+    end
+
+    it "defaults to Pitch 'C4' when no pitches are given" do
+      cycle = Pattern::NoteCycle.new [], [p,f], [1,2,3]
+      cycle.next.should == Note(C4, p, 1)
+      cycle.next.should == Note(C4, f, 2)
+      cycle.next.should == Note(C4, p, 3)
+    end
+
+    it "defaults to intensity 'mf' when no intensities are given" do
+      cycle = Pattern::NoteCycle.new [C4, D4, E4], nil, [2]
+      cycle.next.should == Note(C4, mf, 2)
+      cycle.next.should == Note(D4, mf, 2)
+      cycle.next.should == Note(E4, mf, 2)
+    end
+
+    it "defaults to duration 1 when no durations are given" do
+      cycle = Pattern::NoteCycle.new [C4, D4, E4], [p, f]
+      cycle.next.should == Note(C4, p, 1)
+      cycle.next.should == Note(D4, f, 1)
+      cycle.next.should == Note(E4, p, 1)
+    end
+
+    it "uses the previous pitch/intensity/duration when it encounters a nil value" do
+      cycle = Pattern::NoteCycle.new [C4, D4, E4, F4, nil], [mp, mf, f, nil], [1, 2, nil]
+      cycle.next.should == Note(C4, mp, 1)
+      cycle.next.should == Note(D4, mf, 2)
+      cycle.next.should == Note(E4, f, 2)
+      cycle.next.should == Note(F4, f, 1)
+      cycle.next.should == Note(F4, mp, 2)
+      cycle.next.should == Note(C4, mf, 2)
+    end
+
+    it "adds Numeric intervals in the pitch list to the previous pitch" do
+      cycle = Pattern::NoteCycle.new [C4, 1, 2, 3]
+      cycle.next.should == note(C4)
+      cycle.next.should == note(C4+1)
+      cycle.next.should == note(C4+1+2)
+      cycle.next.should == note(C4+1+2+3)
+      cycle.next.should == note(C4)
+    end
+
+    it "goes to the nearest Pitch for any PitchClasses in the pitch list" do
+      cycle = Pattern::NoteCycle.new [C4, F, C, G, C]
+      cycle.next.should == note(C4)
+      cycle.next.should == note(F4)
+      cycle.next.should == note(C4)
+      cycle.next.should == note(G3)
+      cycle.next.should == note(C4)
+    end
+
+    it "does not endlessly ascend or descend when alternating between two pitch classes a tritone apart" do
+      cycle = Pattern::NoteCycle.new [C4, Gb, C, Gb, C]
+      cycle.next.should == note(C4)
+      cycle.next.should == note(Gb4)
+      cycle.next.should == note(C4)
+      cycle.next.should == note(Gb4)
+      cycle.next.should == note(C4)
+    end
+
+    it "cycles Note Arrays for pitch list items that are PitchSets" do
+      cycle = Pattern::NoteCycle.new [PitchSet.new([C4, E4, G4]), C4, PitchSet.new([D4, F4, A4])]
+      cycle.next.should == [note(C4), note(E4), note(G4)]
+      cycle.next.should == note(C4)
+      cycle.next.should == [note(D4), note(F4), note(A4)]
+    end
+
+    it "adds numeric intervals to PitchSets" do
+      cycle = Pattern::NoteCycle.new [PitchSet.new([C4, E4, G4]), 2]
+      cycle.next.should == [note(C4), note(E4), note(G4)]
+      cycle.next.should == [note(D4), note(Gb4), note(A4)]
+    end
+
+    it "goes to the nearest Pitch relative to the lowest note in the PitchSet for any PitchClasses in the pitch list" do
+      cycle = Pattern::NoteCycle.new [PitchSet.new([C4, E4, G4]), F, D, Bb]
+      cycle.next.should == [note(C4), note(E4), note(G4)]
+      cycle.next.should == [note(F4), note(A4), note(C5)]
+      cycle.next.should == [note(D4), note(Gb4), note(A4)]
+      cycle.next.should == [note(Bb3), note(D4), note(F4)]
+    end
+  end
+
+
+end