mtk 0.0.1

data/spec/mtk/midi/file_spec.rb

@@ -0,0 +1,208 @@
+require 'mtk/midi/file'
+require 'tempfile'
+
+describe MTK::MIDI::File do
+
+  let(:test_mid) { File.join(File.dirname(__FILE__), '..', '..', 'test.mid') }
+
+  def tempfile
+    @tempfile ||= Tempfile.new 'MTK-midi_file_writer_spec'
+  end
+
+  after do
+    if @tempfile
+      @tempfile.close
+      @tempfile.unlink
+    end
+  end
+
+  def note_ons_and_offs(track)
+    note_ons, note_offs = [], []
+    for event in track.events
+      note_ons << event if event.is_a? MIDI::NoteOn
+      note_offs << event if event.is_a? MIDI::NoteOff
+    end
+    return note_ons, note_offs
+  end
+
+  describe "#to_timelines" do
+    it "converts a single-track MIDI file to an Array containing one Timeline" do
+      MIDI_File(test_mid).to_timelines.length.should == 1 # one track
+    end
+
+    it "converts note on/off messages to Note events" do
+      MIDI_File(test_mid).to_timelines.first.should == {
+        0.0 => [Note.new(C4, 126/127.0, 0.25)],
+        1.0 => [Note.new(Db4, 99/127.0, 0.5)],
+        2.0 => [Note.new(D4, 72/127.0, 0.75)],
+        3.0 => [Note.new(Eb4, 46/127.0, 1.0), Note.new(E4, 46/127.0, 1.0)]
+      }
+    end
+  end
+
+  describe "#write_timeline" do
+    it 'writes 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),
+          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 == 3
+        note_offs.length.should == 3
+
+        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 == G4.to_i
+        note_ons[1].velocity.should be_within(0.5).of(127*0.8)
+        note_offs[1].note.should == G4.to_i
+        note_ons[1].time_from_start.should == 480
+        note_offs[1].time_from_start.should == 960
+
+        note_ons[2].note.should == C5.to_i
+        note_ons[2].velocity.should be_within(0.5).of(127*0.9)
+        note_offs[2].note.should == C5.to_i
+        note_ons[2].time_from_start.should == 960
+        note_offs[2].time_from_start.should == 1440
+      end
+    end
+
+    it 'writes Chords 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)
+        })
+      )
+
+      # 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 == 5
+        note_offs.length.should == 5
+
+        note_ons[0].note.should == C4.to_i
+        note_offs[0].note.should == C4.to_i
+        note_ons[0].velocity.should == 64
+        note_ons[0].time_from_start.should == 0
+        note_offs[0].time_from_start.should == 480
+
+        note_ons[1].note.should == E4.to_i
+        note_offs[1].note.should == E4.to_i
+        note_ons[1].velocity.should == 64
+        note_ons[1].time_from_start.should == 0
+        note_offs[1].time_from_start.should == 480
+
+        note_ons[2].note.should == G4.to_i
+        note_offs[2].note.should == G4.to_i
+        note_ons[2].velocity.should == 127
+        note_ons[2].time_from_start.should == 960
+        note_offs[2].time_from_start.should == 1920
+
+        note_ons[3].note.should == B4.to_i
+        note_offs[3].note.should == B4.to_i
+        note_ons[3].velocity.should == 127
+        note_ons[3].time_from_start.should == 960
+        note_offs[3].time_from_start.should == 1920
+
+        note_ons[4].note.should == D5.to_i
+        note_offs[4].note.should == D5.to_i
+        note_ons[4].velocity.should == 127
+        note_ons[4].time_from_start.should == 960
+        note_offs[4].time_from_start.should == 1920
+      end
+    end
+  end
+
+  describe "#write_timelines" do
+    it "writes a multitrack 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),
+        }),
+        Timeline.from_hash({
+          1 => Note.new(C5, 0.9, 2),
+          2 => Note.new(D5, 1, 2),
+        }),
+      ])
+
+      # 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 == 2
+
+        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 == G4.to_i
+        note_ons[1].velocity.should be_within(0.5).of(127*0.8)
+        note_offs[1].note.should == G4.to_i
+        note_ons[1].time_from_start.should == 480
+        note_offs[1].time_from_start.should == 960
+
+        track = seq.tracks[1]
+        note_ons, note_offs = note_ons_and_offs(track)
+        note_ons.length.should == 2
+        note_offs.length.should == 2
+
+        note_ons[0].note.should == C5.to_i
+        note_ons[0].velocity.should be_within(0.5).of(127*0.9)
+        note_offs[0].note.should == C5.to_i
+        note_ons[0].time_from_start.should == 480
+        note_offs[0].time_from_start.should == 1440
+
+        note_ons[1].note.should == D5.to_i
+        note_ons[1].velocity.should == 127
+        note_offs[1].note.should == D5.to_i
+        note_ons[1].time_from_start.should == 960
+        note_offs[1].time_from_start.should == 1920
+      end
+    end
+  end
+
+  describe "#write" do
+    it "calls write_timeline when given a Timeline" do
+      midi_file = MIDI_File(nil)
+      timeline = Timeline.new
+      midi_file.should_receive(:write_timeline).with(timeline)
+      midi_file.write(timeline)
+    end
+
+    it "calls write_timelines when given an Array" do
+      midi_file = MIDI_File(nil)
+      timelines = [Timeline.new]
+      midi_file.should_receive(:write_timelines).with(timelines)
+      midi_file.write(timelines)
+    end
+  end
+
+end

data/spec/mtk/note_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe MTK::Note do
+
+  let(:pitch) { C4 }
+  let(:intensity) { mf }
+  let(:duration) { 2.5 }
+  let(:note) { Note.new(pitch, intensity, duration) }
+
+  describe "#pitch" do
+    it "is the pitch used to create the Note" do
+      note.pitch.should == pitch
+    end
+
+    it "is a read-only attribute" do
+      lambda{ note.pitch = D4 }.should raise_error
+    end
+  end
+
+  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
+    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
+    it "is a hash containing all the attributes of the Note" do
+      note.to_hash.should == { :pitch => pitch, :intensity => intensity, :duration => duration }
+    end
+  end
+
+  describe '#transpose' do
+    it 'adds the given interval to the @pitch' do
+      (note.transpose 2.semitones).should == Note.new(D4, intensity, duration)
+    end
+    it 'does not affect the immutability of the Note' do
+      (note.transpose 2.semitones).should_not == note
+    end
+  end
+
+  describe "#==" do
+    it "is true when the pitches, intensities, and durations are equal" do
+      note.should == Note.new(pitch, intensity, duration)
+    end
+
+    it "is false when the pitches are not equal" do
+      note.should_not == Note.new(pitch + 1, intensity, duration)
+    end
+
+    it "is false when the intensities are not equal" do
+      note.should_not == Note.new(pitch, intensity * 0.5, duration)
+    end
+
+    it "is false when the durations are not equal" do
+      note.should_not == Note.new(pitch, intensity, duration * 2)
+    end
+  end
+
+end

data/spec/mtk/numeric_extensions_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Numeric do
+
+  describe '#semitones' do
+    it "is the Numeric value" do
+      100.semitones.should == 100
+    end
+  end
+
+  describe "#cents" do
+    it "is the Numeric / 100.0" do
+      100.cents.should == 1
+    end
+  end
+
+  describe "#minor_seconds" do
+    it "is the Numeric value" do
+      2.minor_seconds.should == 2
+    end
+  end
+
+  describe "#major_seconds" do
+    it "is the Numeric * 2" do
+      2.major_seconds.should == 4
+    end
+  end
+
+  describe "#minor_thirds" do
+    it "is the Numeric * 3" do
+      2.minor_thirds.should == 6
+    end
+  end
+
+  describe "#major_thirds" do
+    it "is the Numeric * 4" do
+      2.major_thirds.should == 8
+    end
+  end
+
+  describe "#perfect_fourths" do
+    it "is the Numeric * 5" do
+      2.perfect_fourths.should == 10
+    end
+  end
+
+  describe "#tritones" do
+    it "is the Numeric * 6" do
+      2.tritones.should == 12
+    end
+  end
+
+  describe "#augmented_fourths" do
+    it "is the Numeric * 6" do
+      2.augmented_fourths.should == 12
+    end
+  end
+
+  describe "#diminshed_fifths" do
+    it "is the Numeric * 6" do
+      2.diminshed_fifths.should == 12
+    end
+  end
+
+  describe "#perfect_fifths" do
+    it "is the Numeric * 7" do
+      2.perfect_fifths.should == 14
+    end
+  end
+
+  describe "#minor_sixths" do
+    it "is the Numeric * 8" do
+      2.minor_sixths.should == 16
+    end
+  end
+
+  describe "#major_sixths" do
+    it "is the Numeric * 9" do
+      2.major_sixths.should == 18
+    end
+  end
+
+  describe "#minor_sevenths" do
+    it "is the Numeric * 10" do
+      2.minor_sevenths.should == 20
+    end
+  end
+
+  describe "#major_sevenths" do
+    it "is the Numeric * 11" do
+      2.major_sevenths.should == 22
+    end
+  end
+
+  describe "#octaves" do
+    it "is the Numeric * 12" do
+      2.octaves.should == 24
+    end
+  end
+
+end
+

data/spec/mtk/pattern/choice_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'set'
+
+describe MTK::Pattern::Choice do
+
+  let(:elements) { [1,2,3] }
+  let(:choice) { Pattern::Choice.new elements }
+
+  describe "#next" do
+    it "randomly chooses one of the elements" do
+      choosen = Set.new
+      100.times do
+        element = choice.next
+        choosen << element
+        elements.should include(element)
+      end
+      choosen.to_a.sort.should == elements
+    end
+  end
+
+end

data/spec/mtk/pattern/note_sequence_spec.rb

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

data/spec/mtk/pattern/pitch_sequence_spec.rb

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

data/spec/mtk/pattern/sequence_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe MTK::Pattern::Sequence do
+
+  let(:elements) { [1, 2, 3] }
+  let(:sequence) { Pattern::Sequence.new elements }
+
+  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]
+    end
+
+    it "starts at the beginning of the list of elements after the end of the list is reached" do
+      elements.length.times do
+        sequence.next
+      end
+      sequence.next.should == elements.first
+    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
+    end
+
+    it "does not require the lambda to have any parameters" do
+      sequence = Pattern::Sequence.new [lambda { 42 }]
+      sequence.next.should == 42
+    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
+    end
+  end
+
+  describe "#reset" do
+    it "restarts the sequence" do
+      (elements.length - 1).times do
+        sequence.next
+      end
+      sequence.reset
+      sequence.next.should == elements.first
+    end
+  end
+
+end