mtk 0.0.1

data/lib/mtk/timeline.rb

@@ -0,0 +1,160 @@
+module MTK
+
+  # Maps sorted times to lists of events.
+  #
+  # Enumerable as |time,event| pairs.
+  #
+  class Timeline
+
+    include Mappable
+
+    def initialize()
+      @timeline = {}
+    end
+
+    class << self
+      def from_a(enumerable)
+        new.merge enumerable
+      end
+      alias from_hash from_a
+    end
+
+    def merge enumerable
+      for time,events in enumerable
+        add(time,events)
+      end
+      self
+    end
+
+    def clear
+      @timeline.clear
+      self
+    end
+
+    def to_hash
+      @timeline
+    end
+
+    def == other
+      other = other.to_hash unless other.is_a? Hash
+      @timeline == other
+    end
+
+    def [](time)
+      @timeline[time]
+    end
+
+    def []=(time, events)
+      time = time.to_f unless time.is_a? Numeric
+      case events
+        when nil?
+          @timeline.delete time
+        when Array
+          @timeline[time] = events
+        else
+          @timeline[time] = [events]
+      end
+    end
+
+    def add(time, event)
+      events = @timeline[time]
+      if events
+        if event.is_a? Array
+          events.concat event
+        else
+          events << event
+        end
+      else
+         self[time] = event
+      end
+    end
+
+    def delete(time)
+      @timeline.delete(time)
+    end
+
+    def has_time? time
+      @timeline.has_key? time
+    end
+
+    def times
+      @timeline.keys.sort
+    end
+
+    def empty?
+      @timeline.empty?
+    end
+
+    def events
+      times.map{|t| @timeline[t] }.flatten
+    end
+
+    def each
+      times.each do |time|
+        events = @timeline[time]
+        events.each do |event|
+          yield time,event
+        end
+      end
+    end
+
+    def each_time
+      times.each do |time|
+        events = @timeline[time]
+        yield time,events
+      end
+    end
+
+    def map! &block
+      mapped = enumerable_map &block
+      clear
+      merge mapped
+    end
+
+    def map_events
+      mapped_timeline = Timeline.new
+      each_time do |time,events|
+        mapped_timeline[time] = events.map{|event| yield event }
+      end
+      mapped_timeline
+    end
+
+    def map_events!
+      each_time do |time,events|
+        self[time] = events.map{|event| yield event }
+      end
+    end
+
+    def clone
+      self.class.from_hash(to_hash)
+    end
+
+    def compact!
+      @timeline.delete_if {|t,events| events.empty? }
+    end
+    
+    def flatten
+      flattened = Timeline.new
+      for time,event in self
+        if event.is_a? Timeline
+          for subtime, subevent in event.flatten
+            flattened.add(time+subtime, subevent)
+          end
+        else
+          flattened.add(time,event)
+        end
+      end
+      flattened
+    end
+
+    def to_s
+      times.map{|t| "#{t} => #{@timeline[t].join ', '}" }.join "\n"
+    end
+
+    def inspect
+      @timeline.inspect
+    end
+
+  end
+
+end

data/lib/mtk/util/mappable.rb

@@ -0,0 +1,14 @@
+module MTK
+
+  # Similar to Enumerable, but relies on the including Class's from_a method to
+  # provide an implementation of #map which returns an object of the same type
+  module Mappable
+    include Enumerable
+
+    alias enumerable_map map
+    def map &block
+      self.class.from_a(enumerable_map &block)
+    end
+
+  end
+end

data/lib/mtk.rb

@@ -0,0 +1,36 @@
+require 'mtk/util/mappable'
+require 'mtk/pitch_class'
+require 'mtk/pitch_class_set'
+require 'mtk/pitch'
+require 'mtk/pitch_set'
+
+require 'mtk/event'
+require 'mtk/note'
+require 'mtk/chord'
+require 'mtk/timeline'
+
+require 'mtk/constants/pseudo_constants'
+require 'mtk/constants/pitch_classes'
+require 'mtk/constants/pitches'
+require 'mtk/constants/intervals'
+require 'mtk/constants/dynamics'
+
+require 'mtk/numeric_extensions'
+
+
+##############################################
+# Description of modules for documentation:
+
+# The top level module for this library
+module MTK
+
+  # Classes for MIDI input and output
+  module MIDI
+  end
+
+  # Classes that enumerate elements
+  module Pattern
+  end
+
+end
+

data/spec/mtk/chord_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe MTK::Chord do
+
+  let(:pitch_set) { PitchSet.new [C4, E4, G4] }
+  let(:intensity) { mf }
+  let(:duration) { 2.5 }
+  let(:chord) { Chord.new(pitch_set, intensity, duration) }
+
+  it "can be constructed with a PitchSet" do
+    pitch_set = PitchSet.new([C4])
+    Chord.new( pitch_set, intensity, duration ).pitch_set.should == pitch_set
+  end
+
+  it "can be constructed with an Array of Pitches" do
+    Chord.new( [C4], intensity, duration ).pitch_set.should == PitchSet.new([C4])
+  end
+
+  describe "#pitch_set" do
+    it "is the pitch_set used to create the Chord" do
+      chord.pitch_set.should == pitch_set
+    end
+
+    it "is a read-only attribute" do
+      lambda{ chord.pitch_set = PitchSet.new }.should raise_error
+    end
+  end
+
+  describe "#pitches" do
+    it "is the list of pitches in the pitch_set" do
+      chord.pitches.should == chord.pitch_set.pitches
+    end
+  end
+
+  describe "from_hash" do
+    it "constructs a Chord using a hash" do
+      Chord.from_hash({ :pitch_set => pitch_set, :intensity => intensity, :duration => duration }).should == chord
+    end
+  end
+
+  describe "#to_hash" do
+    it "is a hash containing all the attributes of the Chord" do
+      chord.to_hash.should == { :pitch_set => pitch_set, :intensity => intensity, :duration => duration }
+    end
+  end
+
+  describe '#transpose' do
+    it 'adds the given interval to the @pitch_set' do
+      (chord.transpose 2.semitones).should == Chord.new(pitch_set+2, intensity, duration)
+    end
+    it 'does not affect the immutability of the Chord' do
+      (chord.transpose 2.semitones).should_not == chord
+    end
+  end
+
+  describe "#==" do
+    it "is true when the pitch_sets, intensities, and durations are equal" do
+      chord.should == Chord.new(pitch_set, intensity, duration)
+    end
+
+    it "is false when the pitch_sets are not equal" do
+      chord.should_not == Chord.new(pitch_set + 1, intensity, duration)
+    end
+
+    it "is false when the intensities are not equal" do
+      chord.should_not == Chord.new(pitch_set, intensity * 0.5, duration)
+    end
+
+    it "is false when the durations are not equal" do
+      chord.should_not == Chord.new(pitch_set, intensity, duration * 2)
+    end
+  end
+
+end

data/spec/mtk/constants/dynamics_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+  
+describe MTK::Dynamics do
+
+  describe 'ppp' do
+    it 'is equivalent to MIDI velocity 16' do
+      (ppp * 127).round.should == 16
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::ppp.should == ppp
+    end
+  end
+
+  describe 'pp' do
+    it 'is equivalent to MIDI velocity 32' do
+      (pp * 127).round.should == 32
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::pp.should == pp
+    end    
+  end
+
+  describe 'p' do
+    it 'is equivalent to MIDI velocity 48' do
+      (p * 127).round.should == 48
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::p.should == p
+    end    
+  end
+
+  describe 'mp' do
+    it 'is equivalent to MIDI velocity 64' do
+      (mp * 127).round.should == 64
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::mp.should == mp
+    end    
+  end
+
+  describe 'mf' do
+    it 'is equivalent to MIDI velocity 79' do
+      (mf * 127).round.should == 79
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::mf.should == mf
+    end    
+  end
+
+  describe 'f' do
+    it 'is equivalent to MIDI velocity 95' do
+      (f * 127).round.should == 95
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::f.should == f
+    end
+    it "does not overwrite the PitchClass constant 'F'" do
+      F.should be_a PitchClass
+    end    
+  end
+
+  describe 'ff' do
+    it 'is equivalent to MIDI velocity 111' do
+      (ff * 127).round.should == 111
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::ff.should == ff
+    end
+  end
+
+  describe 'fff' do
+    it 'is equivalent to MIDI velocity 127' do
+      (fff * 127).round.should == 127
+    end
+    it 'is available via a module property and via mixin' do
+      Dynamics::fff.should == fff
+    end
+  end
+
+  describe ".[]" do
+    it "looks up the constant by name" do
+      Dynamics['ppp'].should == ppp
+      Dynamics['pp'].should == pp
+      Dynamics['p'].should == p
+      Dynamics['mp'].should == mp
+      Dynamics['mf'].should == mf
+      Dynamics['f'].should == f
+      Dynamics['ff'].should == ff
+      Dynamics['fff'].should == fff
+    end
+  end
+
+end
+  

data/spec/mtk/constants/intervals_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+  
+describe MTK::Intervals do
+
+  describe 'P1' do
+    it 'is 0 semitones' do
+      P1.should == 0
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'm2' do
+    it 'is 1 semitone' do
+      m2.should == 1
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'M2' do
+    it 'is 2 semitones' do
+      M2.should == 2
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'm3' do
+    it 'is 3 semitones' do
+      m3.should == 3
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'M3' do
+    it 'is 4 semitones' do
+      M3.should == 4
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'P4' do
+    it 'is 5 semitones' do
+      P4.should == 5
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'TT' do
+    it 'is 6 semitones' do
+      TT.should == 6
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'P5' do
+    it 'is 7 semitones' do
+      P5.should == 7
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'm6' do
+    it 'is 8 semitones' do
+      m6.should == 8
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'M6' do
+    it 'is 9 semitones' do
+      M6.should == 9
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'm7' do
+    it 'is 10 semitones' do
+      m7.should == 10
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'M7' do
+    it 'is 11 semitones' do
+      M7.should == 11
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe 'P8' do
+    it 'is 12 semitones' do
+      P8.should == 12
+    end
+    it 'is available via a module property and via mixin' do
+      Intervals::P1.should == P1
+    end
+  end
+
+  describe ".[]" do
+    it "looks up the constant by name" do
+      Intervals['P1'].should == P1
+      Intervals['m2'].should == m2
+      Intervals['M2'].should == M2
+      Intervals['m3'].should == m3
+      Intervals['M3'].should == M3
+      Intervals['P4'].should == P4
+      Intervals['TT'].should == TT
+      Intervals['P5'].should == P5
+      Intervals['m6'].should == m6
+      Intervals['M6'].should == M6
+      Intervals['m7'].should == m7
+      Intervals['M7'].should == M7
+      Intervals['P8'].should == P8
+    end
+  end
+
+end

data/spec/mtk/constants/pitch_classes_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe MTK::PitchClasses do
+  let(:cases) {
+    [
+        [PitchClasses::C,  'C',   0],
+        [PitchClasses::Db, 'Db',  1],
+        [PitchClasses::D,  'D',   2],
+        [PitchClasses::Eb, 'Eb',  3],
+        [PitchClasses::E,  'E',   4],
+        [PitchClasses::F,  'F',   5],
+        [PitchClasses::Gb, 'Gb',  6],
+        [PitchClasses::G,  'G',   7],
+        [PitchClasses::Ab, 'Ab',  8],
+        [PitchClasses::A,  'A',   9],
+        [PitchClasses::Bb, 'Bb', 10],
+        [PitchClasses::B,  'B',  11],
+    ]
+  }
+
+  it "defines constants for the 12 pitch classes in the twelve-tone octave" do
+    cases.length.should == 12
+    cases.each do |const, name, int_value|
+      const.name.should == name
+      const.to_i.should == int_value
+    end
+  end
+
+  describe "PITCH_CLASSES" do
+    it "contains the 12 pitch class constants" do
+      PitchClasses::PITCH_CLASSES.length.should == 12
+      PitchClasses::PITCH_CLASSES.should == cases.map{ |const,_,__| const }
+    end
+  end
+end

data/spec/mtk/constants/pitches_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MTK::Pitches do
+
+  it "defines constants for the 128 notes in MIDI" do
+    Pitches.constants.length.should == 129 # there's also the PITCHES constant
+    Pitches::C_1.should == Pitch.from_s('C-1')
+    Pitches::D0.should == Pitch.from_s('D0')
+    Pitches::Eb1.should == Pitch.from_s('Eb1')
+    Pitches::G9.should == Pitch.from_s('g9')
+  end
+
+  describe "PITCHES" do
+    it "contains all 128 pitch constants" do
+      Pitches::PITCHES.length.should == 128
+      Pitches::PITCHES.should include Pitches::C_1
+      Pitches::PITCHES.should include Pitches::D0
+      Pitches::PITCHES.should include Pitches::Eb1
+      Pitches::PITCHES.should include Pitches::G9
+    end
+  end
+
+end

data/spec/mtk/event_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe MTK::Event do
+
+  let(:intensity) { mf }
+  let(:duration) { 2.5 }
+  let(:event) { Event.new(intensity, duration) }
+
+  describe "#intensity" do
+    it "is the intensity used to create the Event" do
+      event.intensity.should == intensity
+    end
+
+    it "is a read-only attribute" do
+      lambda{ event.intensity = 0 }.should raise_error
+    end
+  end
+
+  describe "#duration" do
+    it "is the duration used to create the Event" do
+      event.duration.should == duration
+    end
+
+    it "is a read-only attribute" do
+      lambda{ event.duration = 0 }.should raise_error
+    end
+  end
+
+  describe "from_hash" do
+    it "constructs an Event using a hash" do
+      Event.from_hash({ :intensity => intensity, :duration => duration }).should == event
+    end
+  end
+
+  describe "#to_hash" do
+    it "is a hash containing all the attributes of the Event" do
+      event.to_hash.should == { :intensity => intensity, :duration => duration }
+    end
+  end
+
+  describe "#clone_with" do
+    it "clones the Event when given an empty hash" do
+      event.clone_with({}).should == event
+    end
+
+    it "creates an Event with the given :intensity, and the current Event's duration if not provided" do
+      event2 = event.clone_with :intensity => (intensity * 0.5)
+      event2.intensity.should == (intensity * 0.5)
+      event2.duration.should == duration
+    end
+
+    it "creates an Event with the given :duration, and the current Event's intensity if not provided" do
+      event2 = event.clone_with :duration => (duration * 2)
+      event2.intensity.should == intensity
+      event2.duration.should == (duration * 2)
+    end
+  end
+
+  describe '#scale_intensity' do
+    it 'multiplies @intensity by the argument' do
+      (event.scale_intensity 0.5).should == Event.new(intensity * 0.5, duration)
+    end
+    it 'does not affect the immutability of the Evebt' do
+      (event.scale_intensity 0.5).should_not == event
+    end
+  end
+
+  describe '#scale_duration' do
+    it 'multiplies @duration by the argument' do
+      (event.scale_duration 2).should == Event.new(intensity, duration*2)
+    end
+    it 'does not affect the immutability of the Event' do
+      (event.scale_duration 0.5).should_not == event
+    end
+  end
+
+  describe "#velocity" do
+    it "converts intensities in the range 0.0-1.0 to a MIDI velocity in the range 0-127" do
+      Event.new(0, 0).velocity.should == 0
+      Event.new(1, 0).velocity.should == 127
+    end
+    it "rounds to the nearest MIDI velocity" do
+      Event.new(0.5, 0).velocity.should == 64 # not be truncated to 63!
+    end
+  end
+
+  describe "#duration_in_pulses" do
+    it "converts beats to pulses, given pulses_per_beat" do
+      Event.new(0,1).duration_in_pulses(60).should == 60
+    end
+    it "rounds to the nearest pulse" do
+      Event.new(0,1.5).duration_in_pulses(59).should == 89
+    end
+  end
+
+  describe "#==" do
+    it "is true when the intensities and durations are equal" do
+      event.should == Event.new(intensity, duration)
+    end
+    it "is false when the intensities are not equal" do
+      event.should_not == Event.new(intensity * 0.5, duration)
+    end
+    it "is false when the durations are not equal" do
+      event.should_not == Event.new(intensity, duration * 2)
+    end
+  end
+
+  describe "#to_s" do
+    it "is the intensity and duration to 2-decimal places" do
+      Event.new(0.454545, 0.789789).to_s.should == "0.45, 0.79"
+    end
+  end
+
+  describe "#inspect" do
+    it "is the string values of intensity and duration" do
+      Event.new(0.454545, 0.789789).inspect.should == "0.454545, 0.789789"
+    end
+  end
+
+end