mtk 0.0.1 → 0.0.2

data/spec/mtk/pattern/palindrome_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe MTK::Pattern::Palindrome do
+
+  PALINDROME = MTK::Pattern::Palindrome
+
+  describe "#next" do
+    it "reverses direction when the ends of the list are reached" do
+      palindrome = PALINDROME.new [1,2,3,4]
+      nexts = []
+      12.times { nexts << palindrome.next }
+      nexts.should == [1,2,3, 4,3,2, 1,2,3, 4,3,2]
+    end
+
+    it "reverses direction when the end of the list is reached, and repeats the end (first/last) elements" do
+      palindrome = PALINDROME.new [1,2,3,4], :repeat_ends => true
+      nexts = []
+      12.times { nexts << palindrome.next }
+      nexts.should == [1,2,3,4, 4,3,2,1, 1,2,3,4]
+    end
+
+    it "enumerates nested sequences" do
+      palindrome = PALINDROME.new [1, MTK::Pattern.Sequence(2,3), 4]
+      nexts = []
+      10.times { nexts << palindrome.next }
+      nexts.should == [1,2,3,4, 2,3,1, 2,3,4] # note sequence goes forward in both directions!
+    end
+
+    it "enumerates nested sequences, and repeats the last element" do
+      palindrome = PALINDROME.new [1, MTK::Pattern.Sequence(2,3), 4], :repeat_ends => true
+      nexts = []
+      9.times { nexts << palindrome.next }
+      nexts.should == [1,2,3,4, 4,2,3,1, 1] # note sequence goes forward in both directions!
+    end
+  end
+
+  describe "#rewind" do
+    it "restarts the Palindrome" do
+      palindrome = PALINDROME.new [1,2,3,4]
+      5.times { palindrome.next }
+      palindrome.rewind
+      palindrome.next.should == 1
+      palindrome.next.should == 2
+    end
+  end
+
+  describe "#repeat_ends?" do
+    it "is true if the :repeat_ends option is true" do
+      PALINDROME.new([], :repeat_ends => true).repeat_ends?.should be_true
+    end
+
+    it "is false if the :repeat_ends option is true" do
+      PALINDROME.new([], :repeat_ends => false).repeat_ends?.should be_false
+    end
+  end
+
+  describe "#==" do
+    it "is false if the :repeat_ends options are different" do
+      PALINDROME.new([1,2,3], :repeat_ends => true).should_not == PALINDROME.new([1,2,3], :repeat_ends => false)
+    end
+  end
+
+end
+
+
+describe MTK::Pattern do
+
+  describe "#Palindrome" do
+    it "creates a Palindrome" do
+      MTK::Pattern.Palindrome(1,2,3).should be_a MTK::Pattern::Palindrome
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.Palindrome(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "does not set a type" do
+      MTK::Pattern.Palindrome(1,2,3).type.should be_nil
+    end
+  end
+
+  describe "#PitchPalindrome" do
+    it "creates a Palindrome" do
+      MTK::Pattern.PitchPalindrome(1,2,3).should be_a MTK::Pattern::Palindrome
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.PitchPalindrome(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.PitchPalindrome([]).type.should == :pitch
+    end
+  end
+
+  describe "#IntensityPalindrome" do
+    it "creates a Palindrome" do
+      MTK::Pattern.IntensityPalindrome(1,2,3).should be_a MTK::Pattern::Palindrome
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.IntensityPalindrome(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.IntensityPalindrome([]).type.should == :intensity
+    end
+  end
+
+  describe "#DurationPalindrome" do
+    it "creates a Palindrome" do
+      MTK::Pattern.DurationPalindrome(1,2,3).should be_a MTK::Pattern::Palindrome
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.DurationPalindrome(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.DurationPalindrome([]).type.should == :duration
+    end
+  end
+
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe MTK::Pattern::PitchCycle do
+
+  describe "#next" do
+    it "enumerates Pitches" do
+      cycle = Pattern::PitchCycle.new [C4, D4, E4]
+      cycle.next.should == C4
+      cycle.next.should == D4
+      cycle.next.should == E4
+    end
+
+    it "adds Numeric elements (intervals) to the previous pitch" do
+      cycle = Pattern::PitchCycle.new [C4, 1, 2, 3]
+      cycle.next.should == C4
+      cycle.next.should == C4+1
+      cycle.next.should == C4+1+2
+      cycle.next.should == C4+1+2+3
+    end
+
+    it "returns a Pitch when encountering a Pitch after another type" do
+      cycle = Pattern::PitchCycle.new [C4, 1, C4]
+      cycle.next
+      cycle.next
+      cycle.next.should == C4
+    end
+
+    it "goes to the nearest Pitch for any PitchClasses in the pitch list" do
+      cycle = Pattern::PitchCycle.new [C4, F, C, G, C]
+      cycle.next.should == C4
+      cycle.next.should == F4
+      cycle.next.should == C4
+      cycle.next.should == G3
+      cycle.next.should == C4
+    end
+
+    it "does not endlessly ascend or descend when alternating between two pitch classes a tritone apart" do
+      cycler = Pattern::PitchCycle.new [C4, Gb, C, Gb, C]
+      cycler.next.should == C4
+      cycler.next.should == Gb4
+      cycler.next.should == C4
+      cycler.next.should == Gb4
+      cycler.next.should == C4
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe MTK::Pattern::PitchSequence do
+
+  let(:pitches) { [C4,D4,E4] }
+  let(:pitch_sequence) { Pattern::PitchSequence.new(pitches) }
+
+
+  describe ".from_pitch_classes" do
+    it "creates a pitch sequence from a list of pitch classes and starting point, selecting the nearest pitch to each pitch class" do
+      Pattern::PitchSequence.from_pitch_classes([C,G,B,Eb,D,C], D3).should == [C3,G2,B2,Eb3,D3,C3]
+    end
+
+    it "defaults to a starting point of C4 (middle C)" do
+      Pattern::PitchSequence.from_pitch_classes([C]).should == [C4]
+    end
+
+    it "doesn't travel within an octave above or below the starting point by default" do
+      Pattern::PitchSequence.from_pitch_classes([C,F,Bb,D,A,E,B]).should == [C4,F4,Bb4,D4,A3,E3,B3]
+    end
+
+    it "allows max distance above or below the starting point to be set via the third argument" do
+      Pattern::PitchSequence.from_pitch_classes([C,F,Bb,D,A,E,B], C4, 6).should == [C4,F4,Bb3,D4,A3,E4,B3]
+    end
+  end
+
+
+end
+
+describe MTK::Pattern do
+
+    it "converts the arguments to Pitches when possible" do
+      Pattern.PitchSequence(:C4,:D4,:E4).elements.should == [C4,D4,E4]
+    end
+  end
+
+end

data/spec/mtk/pattern/sequence_spec.rb

@@ -2,53 +2,150 @@ require 'spec_helper'
 
 describe MTK::Pattern::Sequence do
 
-  let(:elements) { [1, 2, 3] }
-  let(:sequence) { Pattern::Sequence.new elements }
+  SEQUENCE = MTK::Pattern::Sequence
 
-  describe "#next" do
-    it "iterates through the list of elements and emits them one at a time" do
-      sequence.next.should == elements[0]
-      sequence.next.should == elements[1]
-      sequence.next.should == elements[2]
+  let(:elements) { [1,2,3] }
+  let(:sequence) { SEQUENCE.new(elements) }
+
+  it "is a MTK::Collection" do
+    sequence.should be_a MTK::Helper::Collection
+    # and now we won't test any other collection features here... see collection_spec
+  end
+
+  describe ".from_a" do
+    it "acts like .new" do
+      SEQUENCE.from_a(elements).should == sequence
     end
+  end
 
-    it "starts at the beginning of the list of elements after the end of the list is reached" do
+  describe "#elements" do
+    it "is the array the sequence was constructed with" do
+      sequence.elements.should == elements
+    end
+  end
+
+  describe "#next" do
+    it "enumerates the elements" do
+      nexts = []
       elements.length.times do
-        sequence.next
+        nexts << sequence.next
       end
-      sequence.next.should == elements.first
+      nexts.should == elements
     end
 
-    it "evaluates any lambdas in the elements list, passing in the previous return value" do
-      sequence = Pattern::Sequence.new [1, lambda { |prev_val| prev_val*10 }]
-      sequence.next
-      sequence.next.should == 10
+    it "raises StopIteration when the end of the Sequence is reached" do
+      elements.length.times{ sequence.next }
+      lambda{ sequence.next }.should raise_error(StopIteration)
+    end
+
+    it "should automatically break out of Kernel#loop" do
+      nexts = []
+      loop do # loop rescues StopIteration and exits the loop
+        nexts << sequence.next
+      end
+      nexts.should == elements
     end
 
-    it "does not require the lambda to have any parameters" do
-      sequence = Pattern::Sequence.new [lambda { 42 }]
-      sequence.next.should == 42
+    it "enumerates the elements in sub-sequences" do
+      sub_sequence = SEQUENCE.new [2,3]
+      sequence = SEQUENCE.new [1,sub_sequence,4]
+      nexts = []
+      loop { nexts << sequence.next }
+      nexts.should == [1,2,3,4]
     end
 
-    it "passed the previous item (which is not necessarily == the previous return value) as the second arg to lambdas that take 2 parameters" do
-      arg1, arg2 = nil, nil
-      return_5 = lambda { 5 }
-      sequence = Pattern::Sequence.new [return_5, lambda { |a1, a2| arg1, arg2=a1, a2 }]
-      sequence.next
-      sequence.next
-      arg1.should == 5
-      arg2.should == return_5
+    it "skips over empty sub-sequences" do
+      sub_sequence = SEQUENCE.new []
+      sequence = SEQUENCE.new [1,sub_sequence,4]
+      nexts = []
+      loop { nexts << sequence.next }
+      nexts.should == [1,4]
     end
+
   end
 
-  describe "#reset" do
-    it "restarts the sequence" do
-      (elements.length - 1).times do
-        sequence.next
-      end
-      sequence.reset
+  describe "#rewind" do
+    it "restarts at the beginning of the sequence" do
+      loop { sequence.next }
+      sequence.rewind
       sequence.next.should == elements.first
     end
+
+    it "returns self, so it can be chained to #next" do
+      first = sequence.next
+      sequence.rewind.next.should == first
+    end
+
+    it "causes sub-sequences to start from the beginning when encountered again after #rewind" do
+      sub_sequence = SEQUENCE.new [2,3]
+      sequence = SEQUENCE.new [1,sub_sequence,4]
+      loop { sequence.next }
+      sequence.rewind
+      nexts = []
+      loop { nexts << sequence.next }
+      nexts.should == [1,2,3,4]
+    end
   end
 
 end
+
+
+describe MTK::Pattern do
+
+  describe "#Sequence" do
+    it "creates a Sequence" do
+      MTK::Pattern.Sequence(1,2,3).should be_a MTK::Pattern::Sequence
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.Sequence(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "does not set a type" do
+      MTK::Pattern.Sequence(1,2,3).type.should be_nil
+    end
+  end
+
+  describe "#PitchSequence" do
+    it "creates a Sequence" do
+      MTK::Pattern.PitchSequence(1,2,3).should be_a MTK::Pattern::Sequence
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.PitchSequence(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.PitchSequence([]).type.should == :pitch
+    end
+  end
+
+  describe "#IntensitySequence" do
+    it "creates a Sequence" do
+      MTK::Pattern.IntensitySequence(1,2,3).should be_a MTK::Pattern::Sequence
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.IntensitySequence(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.IntensitySequence([]).type.should == :intensity
+    end
+  end
+
+  describe "#DurationSequence" do
+    it "creates a Sequence" do
+      MTK::Pattern.DurationSequence(1,2,3).should be_a MTK::Pattern::Sequence
+    end
+
+    it "sets #elements from the varargs" do
+      MTK::Pattern.DurationSequence(1,2,3).elements.should == [1,2,3]
+    end
+
+    it "sets #type to :pitch" do
+      MTK::Pattern.DurationSequence([]).type.should == :duration
+    end
+  end
+
+end

data/spec/mtk/pitch_class_set_spec.rb

@@ -9,6 +9,23 @@ describe MTK::PitchClassSet do
     pitch_class_set.should be_a Enumerable
   end
 
+  describe ".random_row" do
+    it "generates a 12-tone row" do
+      PitchClassSet.random_row.should =~ PitchClasses::PITCH_CLASSES
+    end
+
+    it "generates a random 12-tone row (NOTE: very slight expected chance of test failure, if this fails run it again!)" do
+      # there's a 1/479_001_600 chance this will fail... whaddyagonnado??
+      PitchClassSet.random_row.should_not == PitchClassSet.random_row
+    end
+  end
+
+  describe ".all" do
+    it "is the set of all 12 pitch classes" do
+      PitchClassSet.all.should == PitchClassSet(PitchClasses::PITCH_CLASSES)
+    end
+  end
+
   describe "#pitch_classes" do
     it "is the list of pitch_classes contained in this set" do
       pitch_class_set.pitch_classes.should == pitch_classes
@@ -32,10 +49,6 @@ describe MTK::PitchClassSet do
     it "does not include duplicates" do
       PitchClassSet.new([C, E, G, C]).pitch_classes.should == [C, E, G]
     end
-
-    it "sorts the pitch_classes (C to B)" do
-      PitchClassSet.new([B, E, C]).pitch_classes.should == [C, E, B]
-    end
   end
 
   describe "#to_a" do
@@ -48,6 +61,42 @@ describe MTK::PitchClassSet do
     end
   end
 
+  describe "#size" do
+    it "returns the number of pitch classes in the set" do
+      pitch_class_set.size.should == 3
+    end
+  end
+
+  describe "#length" do
+    it "behaves like #size" do
+      pitch_class_set.length.should == pitch_class_set.size
+    end
+  end
+
+  describe "#[]" do
+    it "accesses the individual pitch classes (like an Array)" do
+      pitch_class_set[0].should == C
+      pitch_class_set[1].should == E
+      pitch_class_set[2].should == G
+    end
+
+    it "returns nil for invalid indexes" do
+      pitch_class_set[pitch_class_set.size].should == nil
+    end
+  end
+
+  describe "#first" do
+    it "is #[0]" do
+      pitch_class_set.first.should == pitch_class_set[0]
+    end
+  end
+
+  describe "#last" do
+    it "is #[-1]" do
+      pitch_class_set.last.should == pitch_class_set[-1]
+    end
+  end
+
   describe "#each" do
     it "yields each pitch_class" do
       pcs = []
@@ -62,6 +111,105 @@ describe MTK::PitchClassSet do
     end
   end
 
+  describe '#transpose' do
+    it 'transposes by the given semitones' do
+      (pitch_class_set.transpose 4.semitones).should == PitchClassSet(E, Ab, B)
+    end
+  end
+
+  describe "#invert" do
+    it 'inverts all pitch_classes around the given center pitch' do
+      pitch_class_set.invert(G).should == PitchClassSet(D,Bb,G)
+    end
+
+    it 'inverts all pitches around the first pitch, when no center pitch is given' do
+      pitch_class_set.invert.should == PitchClassSet(C,Ab,F)
+    end
+  end
+
+  describe "#reverse" do
+    it "produces a PitchClassSet with pitch classes in reverse order" do
+      pitch_class_set.reverse.should == PitchClassSet(G,E,C)
+    end
+  end
+
+  describe "#retrograde" do
+    it "acts like reverse" do
+      pitch_class_set.retrograde.should == pitch_class_set.reverse
+    end
+  end
+
+  describe "#intersection" do
+    it "produces a PitchClassSet containing the common pitch classes from self and the argument" do
+      pitch_class_set.intersection(PitchClassSet(E,G,B)).should == PitchClassSet(E,G)
+    end
+  end
+
+  describe "#union" do
+    it "produces a PitchClassSet containing the all pitch classes from either self or the argument" do
+      pitch_class_set.union(PitchClassSet(E,G,B)).should == PitchClassSet(C,E,G,B)
+    end
+  end
+
+  describe "#difference" do
+    it "produces a PitchClassSet with the pitch classes from the argument removed" do
+      pitch_class_set.difference(PitchClassSet(E)).should == PitchClassSet(C,G)
+    end
+  end
+
+  describe "#symmetric_difference" do
+    it "produces a PitchClassSet containing the pitch classes only in self or only in the argument" do
+      pitch_class_set.symmetric_difference(PitchClassSet(E,G,B)).should == PitchClassSet(C,B)
+    end
+  end
+
+  describe "#complement" do
+    it "produces the set of all PitchClasses not in the current set" do
+      pitch_class_set.complement.should =~ PitchClassSet(Db,D,Eb,F,Gb,Ab,A,Bb,B)
+    end
+  end
+
+  describe "#repeat" do
+    it "does nothing to PitchClassSets, since duplicates are removed from Sets" do
+      pitch_class_set.repeat.should == pitch_class_set
+    end
+  end
+
+  describe "#rotate" do
+    it "produces a PitchClassSet that is rotated by the given offset" do
+      pitch_class_set.rotate(2).should == PitchClassSet(G,C,E)
+      pitch_class_set.rotate(-2).should == PitchClassSet(E,G,C)
+    end
+
+    it "rotates by 1 if no argument is given" do
+      pitch_class_set.rotate.should == pitch_class_set.rotate(1)
+    end
+  end
+
+  describe "#permute" do
+    it "randomly rearranges the PitchClassSet order (NOTE: very slight expected chance of test failure, if this fails run it again!)" do
+      all_pcs = PitchClassSet(PitchClasses::PITCH_CLASSES)
+      permuted = all_pcs.permute
+      permuted.should =~ all_pcs
+      permuted.should_not == all_pcs # there's a 1/479_001_600 chance this will fail...
+    end
+  end
+
+  describe "#shuffle" do
+    it "behaves like permute (NOTE: very slight expected chance of test failure, if this fails run it again!)" do
+      all_pcs = PitchClassSet(PitchClasses::PITCH_CLASSES)
+      shuffled = all_pcs.shuffle
+      shuffled.should =~ all_pcs
+      shuffled.should_not == all_pcs # there's a 1/479_001_600 chance this will fail...
+    end
+  end
+
+  describe "#concat" do
+    it "appends the non-duplicate pitch classes from the other set" do
+      pitch_class_set.concat(PitchClassSet(D,E,F)).should == PitchClassSet(C,E,G,D,F)
+    end
+  end
+
   describe "#normal_order" do
     it "permutes the set so that the first and last pitch classes are as close together as possible" do
       PitchClassSet.new([E,A,C]).normal_order.should == [A,C,E]
@@ -92,12 +240,97 @@ describe MTK::PitchClassSet do
     end
   end
 
-  describe ".span_for" do
-    pending
+  describe "#==" do
+    it "is true if two pitch class sets contain the same set in the same order" do
+      pitch_class_set.should == PitchClassSet(C,E,G)
+    end
+
+    it "is false if two pitch class sets are not in the same order" do
+      pitch_class_set.should_not == PitchClassSet(C,G,E)
+    end
+
+    it "is false if two pitch class sets do not contain the same pitch classes" do
+      pitch_class_set.should_not == PitchClassSet(C,E)
+    end
+
+    it "allows for direct comparison with Arrays" do
+       pitch_class_set.should == [C,E,G]
+    end
+  end
+
+  describe "#=~" do
+    it "is true if two pitch class sets contain the same set in the same order" do
+      pitch_class_set.should =~ PitchClassSet(C,E,G)
+    end
+
+    it "is true if two pitch class sets are not in the same order" do
+      pitch_class_set.should =~ PitchClassSet(C,G,E)
+    end
+
+    it "is false if two pitch class sets do not contain the same pitch classes" do
+      pitch_class_set.should_not =~ PitchClassSet(C,E)
+    end
+
+    it "allows for direct comparison with Arrays" do
+       pitch_class_set.should =~ [C,G,E]
+    end
   end
 
   describe ".span_between" do
-    pending
+    it "is the distance in semitones between 2 pitch classes" do
+      PitchClassSet.span_between(F, Bb).should == 5
+    end
+
+    it "assumes an ascending interval between the arguments (order of arguments matters)" do
+      PitchClassSet.span_between(Bb, F).should == 7
+    end
+  end
+
+  describe ".span_for" do
+    it "measure the distance between the first and last pitch classes" do
+      PitchClassSet.span_for([C,D,E,F,G]).should == 7
+    end
   end
 
 end
+
+describe MTK do
+
+  describe '#PitchClassSet' do
+
+    it "acts like new for a single Array argument" do
+      PitchClassSet([C,D]).should == PitchClassSet.new([C,D])
+    end
+
+    it "acts like new for multiple arguments, by treating them like an Array (splat)" do
+      PitchClassSet(C,D).should == PitchClassSet.new([C,D])
+    end
+
+    it "handles an Array with elements that can be converted to Pitches" do
+      PitchClassSet(['C','D']).should == PitchClassSet.new([C,D])
+    end
+
+    it "handles multiple arguments that can be converted to a Pitch" do
+      PitchClassSet(:C,:D).should == PitchClassSet.new([C,D])
+    end
+
+    it "handles a single Pitch" do
+      PitchClassSet(C).should == PitchClassSet.new([C])
+    end
+
+    it "handles single elements that can be converted to a Pitch" do
+      PitchClassSet('C').should == PitchClassSet.new([C])
+    end
+
+    it "returns the argument if it's already a PitchClassSet" do
+      pitch_set = PitchClassSet.new([C,D])
+      PitchClassSet(pitch_set).should be_equal pitch_set
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ PitchClassSet({:not => :compatible}) }.should raise_error
+    end
+
+  end
+
+end