mtk 0.0.1 → 0.0.2

data/spec/mtk/helper/collection_spec.rb

@@ -0,0 +1,291 @@
+require 'spec_helper'
+
+describe MTK::Helper::Collection do
+
+  class MockCollection
+    include MTK::Helper::Collection
+    attr_reader :elements
+    def initialize(elements); @elements = elements end
+    def self.from_a(elements); new(elements) end
+  end
+
+  class MockCollectionWithOptions
+    include MTK::Helper::Collection
+    attr_reader :elements, :options
+    def initialize(elements, options={})
+      @elements = elements
+      @options = options
+    end
+    def self.from_a(elements, options={})
+      new(elements, options)
+    end
+  end
+
+  let(:elements) { [1,2,3,4,5] }
+  let(:collection) { MockCollection.new elements }
+
+  let(:options) { {:opt1 => :val1, :opt2 => :val2} }
+  let(:collection_with_options) { MockCollectionWithOptions.new(elements, options) }
+
+  it "is Enumerable" do
+    collection.should be_a Enumerable
+  end
+
+  describe "#to_a" do
+    it "is the the Array of elements in the collection" do
+      collection.to_a.should == elements
+    end
+  end
+
+  describe "#size" do
+    it "is the length of the elements" do
+      collection.size.should == elements.length
+    end
+  end
+
+  describe "#length" do
+    it "acts like #size" do
+      collection.length.should == collection.size
+    end
+  end
+
+  describe "#empty?" do
+    it "is true when elements is nil" do
+      MockCollection.new(nil).empty?.should be_true
+    end
+
+    it "is true when elements is empty" do
+      MockCollection.new([]).empty?.should be_true
+    end
+
+    it "is false when elements is not empty" do
+      MockCollection.new([1]).empty?.should be_false
+    end
+  end
+
+  describe "#each" do
+    it "yields each element" do
+      yielded = []
+      collection.each do |element|
+        yielded << element
+      end
+      yielded.should == elements
+    end
+  end
+
+  describe "#first" do
+    it "is #[0] when no argument is given" do
+      collection.first.should == collection[0]
+    end
+
+    it "is the first n elements, for an argument n" do
+      collection.first(3).should == elements[0..2]
+    end
+
+    it "is the elements when n is bigger than elements.length, for an argument n" do
+      collection.first(elements.length * 2).should == elements
+    end
+  end
+
+  describe "#last when no argument is given" do
+    it "is #[-1]" do
+      collection.last.should == collection[-1]
+    end
+
+    it "is the last n elements, for an argument n" do
+      collection.last(3).should == elements[-3..-1]
+    end
+
+    it "is the elements when n is bigger than elements.length, for an argument n" do
+      collection.last(elements.length * 2).should == elements
+    end
+  end
+
+  describe "#[]" do
+    it "accesses an element by index" do
+      collection[3].should == elements[3]
+    end
+
+    it "supports negative indexes" do
+      collection[-1].should == elements[-1]
+    end
+
+    it "accesses ranges of elements" do
+      collection[0..3].should == elements[0..3]
+    end
+  end
+
+  describe "#repeat" do
+    it "repeats the elements the number of times given by the argument" do
+      collection.repeat(3).should == [1,2,3,4,5,1,2,3,4,5,1,2,3,4,5]
+    end
+
+    it "repeats the elements twice if no argument is given" do
+      collection.repeat.should == [1,2,3,4,5,1,2,3,4,5]
+    end
+
+    it "handles fractional repetitions" do
+      collection.repeat(1.6).should == [1,2,3,4,5,1,2,3]
+    end
+
+    it "returns an instance of the same type" do
+      collection.repeat.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.repeat.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.repeat.options.should == options
+    end
+  end
+
+  describe "#permute" do
+    it "randomly rearranges the order of elements" do
+      elements = (0..1000).to_a
+      permuted = MockCollection.new(elements).permute
+      permuted.should_not == elements
+      permuted.sort.should == elements
+    end
+
+    it "returns an instance of the same type" do
+      collection.permute.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.permute.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.permute.options.should == options
+    end
+  end
+
+  describe "#shuffle" do
+    it "behaves like #permute" do
+      elements = (0..1000).to_a
+      shuffled = MockCollection.new(elements).shuffle
+      shuffled.should_not == elements
+      shuffled.sort.should == elements
+    end
+
+    it "returns an instance of the same type" do
+      collection.shuffle.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.shuffle.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.shuffle.options.should == options
+    end
+  end
+
+  describe "#rotate" do
+    it "produces a Collection that is rotated right by the given positive offset" do
+      collection.rotate(2).should == [3,4,5,1,2]
+    end
+
+    it "produces a Collection that is rotated left by the given negative offset" do
+      collection.rotate(-2).should == [4,5,1,2,3]
+    end
+
+    it "rotates by 1 if no argument is given" do
+      collection.rotate.should == [2,3,4,5,1]
+    end
+
+    it "returns an instance of the same type" do
+      collection.rotate.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.rotate.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.rotate.options.should == options
+    end
+  end
+
+  describe "#concat" do
+    it "appends the argument to the elements" do
+      collection.concat([6,7]).should == [1,2,3,4,5,6,7]
+    end
+
+    it "returns an instance of the same type" do
+      collection.concat([6,7]).should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.concat([6,7]).should_not equal collection
+    end
+
+    it "maintains the options from the original (receiver) collection" do
+      collection_with_options.concat([6,7]).options.should == options
+    end
+
+    it "ignored any options from the argument collection" do
+      # I considered merging the options, but it seems potentially too confusing, so
+      # we'll go with this simpler behavior until a use-case appears where this is inappropriate.
+      arg = MockCollectionWithOptions.new(elements, :opt1 => :another_val, :opt3 => :val3)
+      collection_with_options.concat(arg).options.should == options
+    end
+  end
+
+  describe "#reverse" do
+    it "reverses the elements" do
+      collection.reverse.should == elements.reverse
+    end
+
+    it "returns an instance of the same type" do
+      collection.reverse.should be_a collection.class
+    end
+
+    it "does not modify the original collection" do
+      collection.reverse.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.reverse.options.should == options
+    end
+  end
+
+  describe "#==" do
+    it "is true when the elements in 2 Collections are equal" do
+      collection.should == MockCollection.new(elements)
+    end
+
+    it "is true when the elements equal the argument" do
+      collection.should == elements
+    end
+
+    it "is false when the elements in 2 Collections are not equal" do
+      collection.should_not == MockCollection.new(elements + [1,2])
+    end
+
+    it "is false when the elements do not equal the argument" do
+      collection.should_not == (elements + [1,2])
+    end
+
+    it "is false when the options are not equal" do
+      collection.should_not == collection_with_options
+    end
+  end
+
+  describe "#clone" do
+    it "creates an equal collection" do
+      collection.clone.should == collection
+    end
+
+    it "creates a new collection" do
+      collection.clone.should_not equal collection
+    end
+
+    it "maintains the options from the original collection" do
+      collection_with_options.clone.options.should == options
+    end
+  end
+
+end

data/spec/mtk/helper/event_builder_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe MTK::Helper::EventBuilder do
+
+  EVENT_BUILDER = MTK::Helper::EventBuilder
+
+  let(:intensity) { EVENT_BUILDER::DEFAULT_INTENSITY }
+  let(:duration)  { EVENT_BUILDER::DEFAULT_DURATION }
+
+  def notes(*pitches)
+    pitches.map{|pitch| Note(pitch, intensity, duration) }
+  end
+
+
+  describe "#next" do
+    it "builds a single-note list from a single-pitch list argument" do
+      event_builder = EVENT_BUILDER.new [Pattern.Cycle(C4)]
+      event_builder.next.should == notes(C4)
+    end
+
+    it "builds a list of notes from any pitches in the argument" do
+      event_builder = EVENT_BUILDER.new [Pattern.Cycle(C4), Pattern.Cycle(D4)]
+      event_builder.next.should == notes(C4, D4)
+    end
+
+    it "builds a list of notes from pitch sets" do
+      event_builder = EVENT_BUILDER.new [ Pattern.Cycle( PitchSet(C4,D4) ) ]
+      event_builder.next.should == notes(C4, D4)
+    end
+
+    it "builds notes from pitch classes and a default_pitch, selecting the nearest pitch class to the previous pitch" do
+      event_builder = EVENT_BUILDER.new [Pattern.Sequence(C,G,B,Eb,D,C)], :default_pitch => D3
+      notes = []
+      loop do
+        notes << event_builder.next
+      end
+      notes.flatten.should == notes(C3,G2,B2,Eb3,D3,C3)
+    end
+
+    it "defaults to a starting point of C4 (middle C)" do
+      event_builder = EVENT_BUILDER.new [Pattern.Sequence(C4)]
+      event_builder.next.should == notes(C4)
+    end
+
+    it "builds notes from pitch class sets, selecting the neartest pitch classes to the previous/default pitch" do
+      pitch_class_sequence = Pattern::Sequence.new([PitchClassSet(C,G),PitchClassSet(B,Eb),PitchClassSet(D,C)])
+      event_builder = EVENT_BUILDER.new [pitch_class_sequence], :default_pitch => D3
+      event_builder.next.should == notes(C3,G3)
+      event_builder.next.should == notes(B3,Eb3)
+      event_builder.next.should == notes(D3,C3)
+    end
+
+    it "builds notes from by adding Numeric intervals in :pitch type Patterns to the previous Pitch" do
+      event_builder = EVENT_BUILDER.new [ Pattern.PitchSequence( C4, M3, m3, -P5) ]
+      nexts = []
+      loop { nexts << event_builder.next }
+      nexts.should == [notes(C4), notes(E4), notes(G4), notes(C4)]
+    end
+
+    it "builds notes from by adding Numeric intervals in :pitch type Patterns to all pitches in the previous PitchSet" do
+      event_builder = EVENT_BUILDER.new [ Pattern.PitchSequence( PitchSet(C4,Eb4), M3, m3, -P5) ]
+      nexts = []
+      loop { nexts << event_builder.next }
+      nexts.should == [notes(C4,Eb4), notes(E4,G4), notes(G4,Bb4), notes(C4,Eb4)]
+    end
+
+    it "builds notes from intensities" do
+      event_builder = EVENT_BUILDER.new [ Pattern.PitchCycle(C4), Pattern.IntensitySequence(mf, p, fff) ]
+      nexts = []
+      loop { nexts += event_builder.next }
+      nexts.should == [Note(C4, mf, duration), Note(C4, p, duration), Note(C4, fff, duration)]
+    end
+
+    it "builds notes from durations" do
+      event_builder = EVENT_BUILDER.new [ Pattern.PitchCycle(C4), Pattern.DurationSequence(1,2,3) ]
+      nexts = []
+      loop { nexts += event_builder.next }
+      nexts.should == [Note(C4, intensity, 1), Note(C4, intensity, 2), Note(C4, intensity, 3)]
+    end
+  end
+
+  describe "#rewind" do
+    it "resets the state of the EventBuilder" do
+      event_builder = EVENT_BUILDER.new [ Pattern.PitchSequence(C,P8) ]
+      event_builder.next.should == [Note(C4,intensity,duration)]
+      event_builder.next.should == [Note(C5,intensity,duration)]
+      event_builder.rewind
+      event_builder.next.should == [Note(C4,intensity,duration)]
+    end
+  end
+
+end

data/spec/mtk/helper/pseudo_constants_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe MTK::Helper::PseudoConstants do
+
+  module MockConstants
+    extend MTK::Helper::PseudoConstants
+    define_constant 'constant', :value
+  end
+
+  describe "define_constant" do
+    it "defines a method method in the module" do
+      MockConstants::constant.should == :value
+    end
+
+    it "defines a 'module_function'" do
+      MockConstants.constant.should == :value
+    end
+  end
+
+end

data/spec/mtk/lang/grammar_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'mtk/lang/grammar'
+
+describe MTK::Lang::Grammar do
+
+  def parse syntax, root
+    MTK::Lang::Grammar.parse(syntax, root)
+  end
+
+  describe ".parse" do
+
+    it "should parse pitch sequences" do
+      parse("C4 D4 E4", :pitch_sequence).should == Pattern.PitchSequence(C4, D4, E4)
+    end
+
+    it "should parse pitches" do
+      for pitch_class_name in PitchClass::VALID_NAMES
+        for octave in -1..9
+          parse("#{pitch_class_name}#{octave}", :pitch).should == Pitch[PitchClass[pitch_class_name],octave]
+        end
+      end
+    end
+
+    it "should parse pitch classes" do
+      for pitch_class_name in PitchClass::VALID_NAMES
+        parse(pitch_class_name, :pitch_class).should == PitchClass[pitch_class_name]
+      end
+    end
+
+    it "should parse intervals" do
+      for interval_name in Intervals::INTERVAL_NAMES
+        parse(interval_name, :interval).should == Intervals[interval_name]
+      end
+    end
+
+    it "should parse intensities" do
+      for intensity_name in Intensities::INTENSITY_NAMES
+        parse(intensity_name, :intensity).should == Intensities[intensity_name]
+      end
+    end
+
+    it "should parse intensities with + and - modifiers" do
+      for intensity_name in Intensities::INTENSITY_NAMES
+        name = "#{intensity_name}+"
+        parse(name, :intensity).should == Intensities[name]
+        name = "#{intensity_name}-"
+        parse(name, :intensity).should == Intensities[name]
+      end
+    end
+
+    it "should parse durations" do
+      for duration in Durations::DURATION_NAMES
+        parse(duration, :duration).should == Durations[duration]
+      end
+    end
+
+    it "should parse durations with . and t modifiers" do
+      for duration in Durations::DURATION_NAMES
+        name = "#{duration}."
+        parse(name, :duration).should == Durations[name]
+        name = "#{duration}t"
+        parse(name, :duration).should == Durations[name]
+        name = "#{duration}..t.t"
+        parse(name, :duration).should == Durations[name]
+      end
+    end
+
+    it "should parse ints as numbers" do
+      parse("123", :number).should == 123
+    end
+
+    it "should parse floats as numbers" do
+      parse("1.23", :number).should == 1.23
+    end
+
+    it "should parse floats" do
+      parse("1.23", :float).should == 1.23
+    end
+
+    it "should parse negative floats" do
+      parse("-1.23", :float).should == -1.23
+    end
+
+    it "should parse ints" do
+      parse("123", :int).should == 123
+    end
+
+    it "should parse negative ints" do
+      parse("-123", :int).should == -123
+    end
+
+    it "should parse negative ints" do
+      parse("-123", :int).should == -123
+    end
+
+    it "should give nil as the value for whitespace" do
+      parse(" \t\n", :space).should == nil
+    end
+  end
+end

data/spec/mtk/midi/file_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'mtk/midi/file'
 require 'tempfile'
 
@@ -41,11 +42,11 @@ describe MTK::MIDI::File do
   end
 
   describe "#write_timeline" do
-    it 'writes Notes in a Timeline to a MIDI file' do
+    it 'writes monophonic Notes in a Timeline to a MIDI file' do
       MIDI_File(tempfile).write_timeline(
         Timeline.from_hash({
           0 => Note.new(C4, 0.7, 1),
-          1 => Note.new(G4, 0.8, 1),
+          1.0 => Note.new(G4, 0.8, 1),
           2 => Note.new(C5, 0.9, 1)
         })
       )
@@ -81,11 +82,11 @@ describe MTK::MIDI::File do
       end
     end
 
-    it 'writes Chords in a Timeline to a MIDI file' do
+    it 'writes polyphonic (simultaneous) Notes in a Timeline to a MIDI file' do
       MIDI_File(tempfile).write_timeline(
         Timeline.from_hash({
-          0 => Chord.new([C4, E4], 0.5, 1),
-          2 => Chord.new([G4, B4, D5], 1, 2)
+          0 => [Note(C4,0.5,1), Note(E4,0.5,1)],
+          2.0 => [Note(G4,1,2), Note(B4,1,2), Note(D5,1,2)]
         })
       )
 
@@ -131,6 +132,40 @@ describe MTK::MIDI::File do
         note_offs[4].time_from_start.should == 1920
       end
     end
+
+    it 'ignores rests (events with negative duration)' do
+      MIDI_File(tempfile).write_timeline(
+        Timeline.from_hash({
+          0 => Note.new(C4, 0.7, 1),
+          1 => Note.new(G4, 0.8, -1), # this is a rest because it has a negative duration
+          2 => Note.new(C5, 0.9, 1)
+        })
+      )
+
+      # Now let's parse the file and check some expectations
+      File.open(tempfile.path, 'rb') do |file|
+        seq = MIDI::Sequence.new
+        seq.read(file)
+        seq.tracks.size.should == 1
+
+        track = seq.tracks[0]
+        note_ons, note_offs = note_ons_and_offs(track)
+        note_ons.length.should == 2
+        note_offs.length.should == 2
+
+        note_ons[0].note.should == C4.to_i
+        note_ons[0].velocity.should be_within(0.5).of(127*0.7)
+        note_offs[0].note.should == C4.to_i
+        note_ons[0].time_from_start.should == 0
+        note_offs[0].time_from_start.should == 480
+
+        note_ons[1].note.should == C5.to_i
+        note_ons[1].velocity.should be_within(0.5).of(127*0.9)
+        note_offs[1].note.should == C5.to_i
+        note_ons[1].time_from_start.should == 960
+        note_offs[1].time_from_start.should == 1440
+      end
+    end
   end
 
   describe "#write_timelines" do
@@ -138,7 +173,7 @@ describe MTK::MIDI::File do
       MIDI_File(tempfile).write_timelines([
         Timeline.from_hash({
           0 => Note.new(C4, 0.7, 1),
-          1 => Note.new(G4, 0.8, 1),
+          1.0 => Note.new(G4, 0.8, 1),
         }),
         Timeline.from_hash({
           1 => Note.new(C5, 0.9, 2),

data/spec/mtk/note_spec.rb

@@ -17,19 +17,25 @@ describe MTK::Note do
     end
   end
 
-  describe "from_hash" do
+  describe ".from_hash" do
     it "constructs a Note using a hash" do
       Note.from_hash({ :pitch => C4, :intensity => intensity, :duration => duration }).should == note
     end
   end
 
-  describe 'from_midi' do
+  describe '.from_midi' do
     it "constructs a Note using a MIDI pitch and velocity" do
       Note.from_midi(C4.to_i, mf*127, 2.5).should == note
     end
   end
 
-  describe "to_hash" do
+  describe "#to_midi" do
+    it "converts the Note to an Array of MIDI values: [pitch, velocity, duration]" do
+      note.to_midi.should == [60, (mf*127).round, duration]
+    end
+  end
+
+  describe "#to_hash" do
     it "is a hash containing all the attributes of the Note" do
       note.to_hash.should == { :pitch => pitch, :intensity => intensity, :duration => duration }
     end
@@ -44,6 +50,24 @@ describe MTK::Note do
     end
   end
 
+  describe "#invert" do
+    context 'higher center pitch' do
+      it 'inverts the pitch around the given center pitch' do
+        note.invert(Pitch 66).should == Note.new(Pitch(72), intensity, duration)
+      end
+    end
+
+    context 'lower center pitch' do
+      it 'inverts the pitch around the given center pitch' do
+        note.invert(Pitch 54).should == Note.new(Pitch(48), intensity, duration)
+      end
+    end
+
+    it "returns the an equal note when given it's pitch as an argument" do
+      note.invert(note.pitch).should == note
+    end
+  end
+
   describe "#==" do
     it "is true when the pitches, intensities, and durations are equal" do
       note.should == Note.new(pitch, intensity, duration)
@@ -63,3 +87,29 @@ describe MTK::Note do
   end
 
 end
+
+describe MTK do
+
+  describe '#Note' do
+
+    it "acts like new for multiple arguments" do
+      Note(C4,mf,1).should == Note.new(C4,mf,1)
+    end
+
+    it "acts like new for an Array of arguments by unpacking (splatting) them" do
+      Note([C4,mf,1]).should == Note.new(C4,mf,1)
+    end
+
+    it "returns the argument if it's already a Note" do
+      note = Note.new(C4,mf,1)
+      Note(note).should be_equal note
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Note({:not => :compatible}) }.should raise_error
+    end
+
+  end
+
+end
+