mtk 0.0.1 → 0.0.2

data/spec/mtk/pitch_class_spec.rb

@@ -23,34 +23,62 @@ describe MTK::PitchClass do
     it "is the 12 note names in western chromatic scale" do
       PitchClass::NAMES =~ ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B']
     end
+
+    it "is immutable" do
+      lambda{ PitchClass::NAMES << 'H' }.should raise_error
+    end
+  end
+
+  describe 'VALID_NAMES' do
+    it "is all enharmonic spellings of NAMES including sharps, flats, double-sharps, and double-flats" do
+      PitchClass::VALID_NAMES =~ names
+    end
+
+    it "is immutable" do
+      lambda{ PitchClass::VALID_NAMES << 'H' }.should raise_error
+    end
+  end
+
+  describe '.new' do
+    it "is private" do
+      lambda{ PitchClass.new('C',0) }.should raise_error
+    end
   end
 
   describe '.from_s' do
     context "the argument is a valid name" do
       it "returns a PitchClass" do
-        names.each { |name| PitchClass.from_s(name).should be_a PitchClass }
+        names.each { |name| PitchClass[name].should be_a PitchClass }
       end
       it "returns an object with that name" do
-        names.each { |name| PitchClass.from_s(name).name.should == name }
+        names.each { |name| PitchClass[name].name.should == name }
       end
       it "ignores case" do
         for name in names
-          PitchClass.from_s(name.upcase).name.should == name
-          PitchClass.from_s(name.downcase).name.should == name
+          PitchClass[name.upcase].name.should == name
+          PitchClass[name.downcase].name.should == name
         end
       end
     end
     context "the argument is not a valid name" do
       it "returns nil, if the name doesn't exist" do
-        PitchClass.from_s('z').should be_nil
+        PitchClass['z'].should be_nil
+      end
+    end
+  end
+
+  describe '.from_s' do
+    it "acts like .[]" do
+      for name in ['C', 'bbb', 'z']
+        PitchClass.from_s(name).should == PitchClass[name]
       end
     end
   end
 
   describe '.from_name' do
-    it "acts like from_s" do
+    it "acts like .[]" do
       for name in ['C', 'bbb', 'z']
-        PitchClass.from_name(name).should == PitchClass.from_s(name)
+        PitchClass.from_name(name).should == PitchClass[name]
       end
     end
   end
@@ -59,21 +87,13 @@ describe MTK::PitchClass do
     it "returns the PitchClass with that value" do
       PitchClass.from_i(2).should == D
     end
+
     it "returns the PitchClass with that value mod 12" do
       PitchClass.from_i(14).should == D
       PitchClass.from_i(-8).should == E
     end
   end
 
-  describe '.[]' do
-    it "acts like from_name if the argument is a string" do
-      PitchClass['D'].should == PitchClass.from_name('D')
-    end
-    it "acts like from_i if the argument is a number" do
-      PitchClass[3].should == PitchClass.from_i(3)
-    end
-  end
-
   describe '#name' do
     it "is the name of the pitch class" do
       C.name.should == 'C'
@@ -103,8 +123,8 @@ describe MTK::PitchClass do
       C.should_not == D
     end
     it "treats enharmonic names as equal" do
-      C.should == PitchClass['B#']
-      C.should == PitchClass['Dbb']
+      C.should == PitchClass('B#')
+      C.should == PitchClass('Dbb')
     end
   end
 
@@ -125,6 +145,12 @@ describe MTK::PitchClass do
     end
   end
 
+  describe "#transpose" do
+    it "behaves like #+" do
+      C.transpose(2.semitones).should == C + 2
+    end
+  end
+
   describe '#-' do
     it "subtracts the integer value of the argument from #to_i" do
       (E - 2).should == D
@@ -135,6 +161,20 @@ describe MTK::PitchClass do
     end
   end
 
+  describe "#invert" do
+    it 'inverts the pitch class around the given center pitch class' do
+      E.invert(D).should == C
+    end
+
+    it 'wraps around octaves as needed (always returns a valid pitch class)' do
+      E.invert(B).should == Gb
+    end
+
+    it "returns the pitch class when the argument is the same pitch class" do
+      E.invert(E).should == E
+    end
+  end
+
   describe "#distance_to" do
     it "is the distance in semitones between 2 PitchClass objects" do
       C.distance_to(D).should == 2
@@ -163,3 +203,29 @@ describe MTK::PitchClass do
   end
 
 end  
+
+describe MTK do
+
+  describe '#PitchClass' do
+    it "acts like from_s if the argument is a String" do
+      PitchClass('D').should == PitchClass.from_s('D')
+    end
+
+    it "acts like from_s if the argument is a Symbol" do
+      PitchClass(:D).should == PitchClass.from_s('D')
+    end
+
+    it "acts like from_i if the argument is a Numberic" do
+      PitchClass(3).should == PitchClass.from_i(3)
+    end
+
+    it "returns the argument if it's already a PitchClass" do
+      PitchClass(C).should be_equal C
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ PitchClass({:not => :compatible}) }.should raise_error
+    end
+  end
+
+end

data/spec/mtk/pitch_set_spec.rb

@@ -83,15 +83,9 @@ describe MTK::PitchSet do
     end
   end
 
-  describe '#+' do
+  describe '#transpose' do
     it 'transposes upward by the given semitones' do
-      (pitch_set + 12).should == PitchSet.new([C5, D5, E5, F5, G5, A5, B5])
-    end
-  end
-
-  describe '#-' do
-    it 'transposes downward by the given semitones' do
-      (pitch_set - 12).should == PitchSet.new([C3, D3, E3, F3, G3, A3, B3])
+      pitch_set.transpose(12).should == PitchSet.new([C5, D5, E5, F5, G5, A5, B5])
     end
   end
 
@@ -149,8 +143,8 @@ describe MTK::PitchSet do
 
   describe "#nearest" do
     it "returns the nearest PitchSet where the first Pitch has the given PitchClass" do
-      c_major.nearest(F).should == c_major + 5
-      c_major.nearest(G).should == c_major - 5
+      c_major.nearest(F).should == c_major.transpose(5.semitones)
+      c_major.nearest(G).should == c_major.transpose(-5.semitones)
     end
   end
 
@@ -161,3 +155,44 @@ describe MTK::PitchSet do
   end
 
 end
+
+describe MTK do
+
+  describe '#PitchSet' do
+
+    it "acts like new for a single Array argument" do
+      PitchSet([C4,D4]).should == PitchSet.new([C4,D4])
+    end
+
+    it "acts like new for multiple arguments, by treating them like an Array (splat)" do
+      PitchSet(C4,D4).should == PitchSet.new([C4,D4])
+    end
+
+    it "handles an Array with elements that can be converted to Pitches" do
+      PitchSet(['C4','D4']).should == PitchSet.new([C4,D4])
+    end
+
+    it "handles multiple arguments that can be converted to a Pitch" do
+      PitchSet(:C4,:D4).should == PitchSet.new([C4,D4])
+    end
+
+    it "handles a single Pitch" do
+      PitchSet(C4).should == PitchSet.new([C4])
+    end
+
+    it "handles single elements that can be converted to a Pitch" do
+      PitchSet('C4').should == PitchSet.new([C4])
+    end
+
+    it "returns the argument if it's already a PitchSet" do
+      pitch_set = PitchSet.new([C4,D4])
+      PitchSet(pitch_set).should be_equal pitch_set
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ PitchSet({:not => :compatible}) }.should raise_error
+    end
+
+  end
+
+end

data/spec/mtk/pitch_spec.rb

@@ -11,9 +11,14 @@ describe MTK::Pitch do
     it "constructs and caches a pitch with the given pitch_class and octave" do
       Pitch[C,4].should be_equal Pitch[C,4]
     end
+
     it "retains the new() method's ability to construct uncached objects" do
       Pitch.new(C,4).should_not be_equal Pitch[C,4]
     end
+
+    it "can handle any type for the first argument that's supported by MTK::PitchClass()" do
+      Pitch['C',4].should == Pitch[0, 4]
+    end
   end
 
   describe '#pitch_class' do
@@ -62,6 +67,16 @@ describe MTK::Pitch do
     it("converts 'C4' to middle c") { Pitch.from_s('C4').should == middle_c }
     it("converts 'c4' to middle c") { Pitch.from_s('c4').should == middle_c }
     it("converts 'B#4' to middle c") { Pitch.from_s('B#4').should == middle_c }
+    it("converts 'C-1' to a low c, 5 octaves below middle C") { Pitch.from_s('C-1').should == middle_c - 60 }
+    it("converts 'C4+50.0cents' to middle C and 50 cents") { Pitch.from_s('C4+50.0cents').should == middle_c_and_50_cents }
+  end
+
+  describe '.from_name' do
+    it "acts like .from_s" do
+      for name in ['C4', 'c4', 'B#4', 'C-1', 'C4+50.0cents']
+        Pitch.from_name(name).should == Pitch.from_s(name)
+      end
+    end
   end
 
   describe ".from_hash" do
@@ -139,6 +154,12 @@ describe MTK::Pitch do
     end
   end
 
+  describe "#transpose" do
+    it "behaves like #+" do
+      middle_c.transpose(2.semitones).should == middle_c + 2
+    end
+  end
+
   describe '#-' do
     it 'subtracts the integer value of the argument from #to_i' do
       (middle_c - 2).should == Pitch.from_i(58)
@@ -168,6 +189,10 @@ describe MTK::Pitch do
         middle_c.invert(Pitch.from_i 54).should == Pitch.from_i(48)
       end
     end
+
+    it "returns an equal pitch when given itself as an argument" do
+      middle_c.invert(middle_c).should == middle_c
+    end
   end
 
   describe "#nearest" do
@@ -215,3 +240,37 @@ describe MTK::Pitch do
   end
 
 end
+
+describe MTK do
+
+  describe '#Pitch' do
+    it "acts like from_s if the argument is a String" do
+      Pitch('D4').should == Pitch.from_s('D4')
+    end
+
+    it "acts like from_s if the argument is a Symbol" do
+      Pitch(:D4).should == Pitch.from_s(:D4)
+    end
+
+    it "acts like from_f if the argument is a Numberic" do
+      Pitch(3).should == Pitch.from_f(3)
+    end
+
+    it "returns the argument if it's already a PitchClass" do
+      Pitch(C4).should be_equal C4
+    end
+
+    it "acts like Pitch[] for a 2-element Array" do
+      Pitch(C,4).should == Pitch[C,4]
+    end
+
+    it "acts like Pitch.new() for a 3-element Array" do
+      Pitch(C, 4, 0.5).should == Pitch.new(C, 4, 0.5)
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Pitch({:not => :compatible}) }.should raise_error
+    end
+  end
+
+end

data/spec/mtk/sequencer/abstract_sequencer_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe MTK::Sequencer::AbstractSequencer do
+
+  ABSTRACT_SEQUENCER = Sequencer::AbstractSequencer
+
+  class MockEventBuilder < Helper::EventBuilder
+    attr_accessor :mock_attribute
+  end
+
+  let(:patterns)  { [Pattern.PitchCycle(C4,D4)] }
+  let(:sequencer) { ABSTRACT_SEQUENCER.new patterns }
+  let(:intensity) { Helper::EventBuilder::DEFAULT_INTENSITY }
+  let(:duration)  { Helper::EventBuilder::DEFAULT_DURATION }
+
+  describe "#new" do
+    it "defaults @max_steps to nil" do
+      sequencer.max_steps.should be_nil
+    end
+
+    it "sets @max_steps from the options hash" do
+      sequencer = RHYTHMIC_SEQUENCER.new patterns, :max_steps => 4
+      sequencer.max_steps.should == 4
+    end
+
+    it "defaults @max_time to nil" do
+      sequencer.max_time.should be_nil
+    end
+
+    it "sets @max_time from the options hash" do
+      sequencer = RHYTHMIC_SEQUENCER.new patterns, :max_time => 4
+      sequencer.max_time.should == 4
+    end
+
+    it "defaults @event_builder to MTK::Helper::EventBuilder" do
+      sequencer.event_builder.should be_a MTK::Helper::EventBuilder
+    end
+
+    it "sets @event_buidler from the options hash" do
+      sequencer = RHYTHMIC_SEQUENCER.new patterns, :event_builder => MockEventBuilder
+      sequencer.event_builder.should be_a MockEventBuilder
+    end
+  end
+
+  describe "#event_builder" do
+    it "provides access to the internal EventBuilder" do
+      sequencer = RHYTHMIC_SEQUENCER.new patterns, :event_builder => MockEventBuilder
+      sequencer.event_builder.mock_attribute = :value
+      sequencer.event_builder.mock_attribute.should == :value
+    end
+  end
+
+  describe "#to_timeline" do
+    it "combines pitch, intensity, and duration patterns into notes" do
+      pitches = Pattern.PitchSequence(C4, D4, E4)
+      intensities = Pattern.IntensitySequence(0.3, 0.7, 1.0)
+      durations = Pattern.DurationSequence(1, 2, 3)
+      sequencer = ABSTRACT_SEQUENCER.new [pitches, intensities, durations]
+      # default implementation just increments the time by 1 for each event (more interesting behavior is provided by subclasses)
+      sequencer.to_timeline.should == {
+        0 => [Note(C4,0.3,1)],
+        1 => [Note(D4,0.7,2)],
+        2 => [Note(E4,1.0,3)]
+      }
+    end
+
+    it "combines patterns of different types and lengths" do
+      pitches = Pattern.PitchSequence(C4, D4, E4, F4, G4, A4, B4, C5)
+      intensities = Pattern.IntensityCycle(0.5, 1.0)
+      durations = Pattern.DurationPalindrome(1, 2, 3)
+      sequencer = ABSTRACT_SEQUENCER.new [pitches, intensities, durations]
+      # default implementation just increments the time by 1 for each event (more interesting behavior is provided by subclasses)
+      sequencer.to_timeline.should == {
+        0 => [Note(C4,0.5,1)],
+        1 => [Note(D4,1.0,2)],
+        2 => [Note(E4,0.5,3)],
+        3 => [Note(F4,1.0,2)],
+        4 => [Note(G4,0.5,1)],
+        5 => [Note(A4,1.0,2)],
+        6 => [Note(B4,0.5,3)],
+        7 => [Note(C5,1.0,2)]
+      }
+    end
+
+    it "produces consistent results by reseting the patterns each time" do
+      pitches = Pattern.PitchSequence(C4, D4, E4)
+      intensities = Pattern.IntensityCycle(1)
+      durations = Pattern.DurationCycle(1, 2)
+      sequencer = ABSTRACT_SEQUENCER.new [pitches, intensities, durations]
+      sequencer.to_timeline.should == sequencer.to_timeline
+    end
+  end
+
+  describe "#time" do
+    it "is the current timeline time that the sequencer is generating events for" do
+      # AbstractSequencer just advances by 1 each step
+      sequencer.next # time doesn't advance until the second #next call
+      sequencer.time.should == 0
+      sequencer.next
+      sequencer.time.should == 1
+      sequencer.next
+      sequencer.time.should == 2
+    end
+  end
+
+  describe "#step" do
+    it "is the index for how many of times #next has been called (i.e. count starting from 0)" do
+      sequencer.step.should == -1 # -1 indicates #next has not yet been called
+      sequencer.next
+      sequencer.step.should == 0
+      sequencer.next
+      sequencer.step.should == 1
+      sequencer.next
+      sequencer.step.should == 2
+    end
+  end
+
+  describe "#next" do
+    it "returns a list of notes formed from the patterns in the sequencer"  do
+      sequencer.next.should == [Note(C4,intensity,duration)]
+      sequencer.next.should == [Note(D4,intensity,duration)]
+      sequencer.next.should == [Note(C4,intensity,duration)]
+    end
+  end
+
+  describe "#rewind" do
+    it "resets the sequencer and its patterns" do
+      sequencer.next
+      sequencer.rewind
+      sequencer.step.should == -1
+      sequencer.time.should == 0
+      sequencer.next.should == [Note(C4,intensity,duration)]
+    end
+
+    it "resets pitches properly for patterns that rely on previous pitches" do
+      relative_pitch_pattern = Pattern.PitchSequence(C,P8)
+      sequencer = ABSTRACT_SEQUENCER.new [relative_pitch_pattern]
+      sequencer.next.should == [Note(C4,intensity,duration)]
+      sequencer.next.should == [Note(C5,intensity,duration)]
+      sequencer.rewind
+      sequencer.next.should == [Note(C4,intensity,duration)] # if the internal EventBuilder is not properly reset, the Note would be C5
+    end
+  end
+
+  describe "#max_steps" do
+    it "controls the maximum number of entries in the generated timeline" do
+      sequencer.max_steps = 2
+      sequencer.to_timeline.times.length.should == 2
+    end
+  end
+
+  describe "#max_time" do
+    it "controls the maximum time in the generated timeline" do
+      sequencer.max_time = 4
+      sequencer.to_timeline.times.last.should == 4
+    end
+  end
+
+end

data/spec/mtk/sequencer/rhythmic_sequencer_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe MTK::Sequencer::RhythmicSequencer do
+
+  RHYTHMIC_SEQUENCER = Sequencer::RhythmicSequencer
+
+  let(:pitches)     { Pattern.PitchSequence(C4, D4, E4, C4) }
+  let(:intensities) { Pattern.IntensitySequence(0.3, 0.6, 0.9, 1.0) }
+  let(:durations)   { Pattern.DurationSequence(1, 1, 2, 1) }
+  let(:rhythm)      { Pattern.RhythmSequence(0.5, 1.5, 4) }
+  let(:rhythmic_sequencer) { RHYTHMIC_SEQUENCER.new [pitches, durations, intensities, rhythm] }
+
+  describe "#new" do
+    it "defaults @max_steps to nil" do
+      rhythmic_sequencer.max_steps.should be_nil
+    end
+
+    it "sets @max_steps from the options hash" do
+      rhythmic_sequencer = RHYTHMIC_SEQUENCER.new [], :max_steps => 4
+      rhythmic_sequencer.max_steps.should == 4
+    end
+  end
+
+  describe "#to_timeline" do
+    it "returns a Timeline" do
+      rhythmic_sequencer.to_timeline.should be_a Timeline
+    end
+
+    it "contains notes assembled from the given patterns" do
+      rhythmic_sequencer.to_timeline.should == Timeline.from_hash({
+        0 => Note(C4,0.3,1),
+        0.5 => Note(D4,0.6,1),
+        2.0 => Note(E4,0.9,2),
+        6.0 => Note(C4,1.0,1)
+      })
+    end
+  end
+
+  describe "#max_steps" do
+    it "controls the maximum number of times in the generated timeline" do
+      rhythmic_sequencer.max_steps = 2
+      rhythmic_sequencer.to_timeline.should == Timeline.from_hash({
+        0 => Note(C4,0.3,1),
+        0.5 => Note(D4,0.6,1)
+      })
+    end
+  end
+
+end

data/spec/mtk/sequencer/step_sequencer_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe MTK::Sequencer::StepSequencer do
+
+  STEP_SEQUENCER = Sequencer::StepSequencer
+
+  let(:pitches)     { Pattern.PitchSequence(C4, D4, E4) }
+  let(:intensities) { Pattern.IntensitySequence(0.3, 0.7, 1.0) }
+  let(:durations)   { Pattern.DurationSequence(1, 1, 2) }
+  let(:step_sequencer) { STEP_SEQUENCER.new [pitches, intensities, durations] }
+
+  describe "#new" do
+    it "defaults @step_size to 1" do
+      step_sequencer.step_size.should == 1
+    end
+
+    it "sets @step_size from the options hash" do
+      step_sequencer = STEP_SEQUENCER.new [], :step_size => 0.25
+      step_sequencer.step_size.should == 0.25
+    end
+
+    it "defaults @max_steps to nil" do
+      step_sequencer.max_steps.should be_nil
+    end
+
+    it "sets @max_steps from the options hash" do
+      step_sequencer = STEP_SEQUENCER.new [], :max_steps => 4
+      step_sequencer.max_steps.should == 4
+    end
+  end
+
+  describe "#to_timeline" do
+    it "returns a Timeline" do
+      timeline = step_sequencer.to_timeline
+      timeline.should be_a Timeline
+    end
+
+    it "contains notes assembled from the given patterns" do
+      timeline = step_sequencer.to_timeline
+      timeline.should == Timeline.from_hash({
+        0 => Note(C4,0.3,1),
+        1 => Note(D4,0.7,1),
+        2 => Note(E4,1.0,2)
+      })
+    end
+  end
+
+  describe "#step_size" do
+    it "controls the delta between each time in the generated timeline" do
+      step_sequencer.step_size = 2
+      timeline = step_sequencer.to_timeline
+      timeline.should == Timeline.from_hash({
+        0 => Note(C4,0.3,1),
+        2 => Note(D4,0.7,1),
+        4 => Note(E4,1.0,2)
+      })
+    end
+  end
+
+  describe "#max_steps" do
+    it "controls the maximum number of times in the generated timeline" do
+      step_sequencer.max_steps = 2
+      timeline = step_sequencer.to_timeline
+      timeline.should == Timeline.from_hash({
+        0 => Note(C4,0.3,1),
+        1 => Note(D4,0.7,1)
+      })
+    end
+  end
+
+end