mtk 0.0.3.2 → 0.0.3.3

data/lib/mtk/sequencers/sequencer.rb

@@ -1,24 +1,24 @@
 module MTK
   module Sequencers
 
-    # A Sequencer produces {Timeline}s from a collection of {Patterns::Pattern}s.
+    # A Sequencer produces {Events::Timeline}s from a collection of {Patterns::Pattern}s.
     #
     # @abstract Subclass and override {#advance} to implement a Sequencer.
     #
     class Sequencer
 
-      # The maximum number of [time,event_list] entries that will be generated for the {Timeline}.
+      # The maximum number of [time,event_list] entries that will be generated for the {Events::Timeline}.
       # nil means no maximum (be careful of infinite loops!)
       attr_accessor :max_steps
 
-      # The maximum time (key) that will be generated for the {Timeline}.
+      # The maximum time (key) that will be generated for the {Events::Timeline}.
       # nil means no maximum (be careful of infinite loops!)
       attr_accessor :max_time
 
       # Used by {#to_timeline} to builds event lists from the results of {Patterns::Pattern#next} for the {Patterns::Pattern}s in this Sequencer.
       attr_reader :event_builder
 
-      # The current time offset for the sequencer. Used for the {Timeline} times.
+      # The current time offset for the sequencer. Used for the {Events::Timeline} times.
       attr_reader :time
 
       # The current sequencer step index (the number of times-1 that {#next} has been called), or -1 if the sequencer has not yet started.
@@ -26,7 +26,7 @@ module MTK
 
       attr_reader :patterns
 
-      # @param patterns [Array] the list of patterns to be sequenced into a {Timeline}
+      # @param patterns [Array] the list of patterns to be sequenced into a {Events::Timeline}
       # @param  options [Hash] the options to create a message with.
       # @option options [String] :max_steps set {#max_steps}
       # @option options [String] :max_time set {#max_time}
@@ -45,10 +45,10 @@ module MTK
       end
 
 
-      # Produce a {Timeline} from the {Patterns::Pattern}s in this Sequencer.
+      # Produce a {Events::Timeline} from the {Patterns::Pattern}s in this Sequencer.
       def to_timeline
         rewind
-        timeline = Timeline.new
+        timeline =  MTK::Events::Timeline.new
         loop do
           events = self.next
           if events
@@ -89,7 +89,7 @@ module MTK
       ########################
       protected
 
-      # Advance @time to the next time for the {Timeline} being produced by {#to_timeline}
+      # Advance @time to the next time for the {Events::Timeline} being produced by {#to_timeline}
       def advance
         @time += 1 # default behavior simply advances one beat at a time
       end

data/lib/mtk/sequencers/step_sequencer.rb

@@ -1,10 +1,10 @@
 module MTK
   module Sequencers
 
-    # A Sequencer which has a constant {#step_size} time between {Timeline} entries.
+    # A Sequencer which has a constant {#step_size} time between {Events::Timeline} entries.
     class StepSequencer < Sequencer
 
-      # The time between entries in the {Timeline}.
+      # The time between entries in the {Events::Timeline}.
       attr_accessor :step_size
 
       def initialize(patterns, options={})

data/lib/mtk.rb

@@ -3,65 +3,61 @@
 # The top level module for this library
 module MTK
 
-  # Constants for modeling frequency, intensity, and duration.
-  module Constants
+  # Core data types
+  module Core
   end
 
-  # Internal helper classes used to avoid duplicating code in this library.
-  module Helpers
-  end
-
-  # Musical events, such as {Events::Note}s and {Events::Parameter} changes, that are arranged in time via a {Timeline}.
+  # Musical events, such as {MTK::Events::Note}s and {MTK::Events::Parameter} changes, that are arranged in time via a {MTK::Events::Timeline}.
   module Events
   end
 
-  # Classes that emit elements one at a time. Used by {MTK::Sequencers::Sequencer}s to construct {Timeline}s.
-  module Patterns
+  # Collections of {MTK::Core} objects
+  module Groups
   end
 
-  # Classes that assemble {Patterns::Pattern}s into {Timeline}s.
-  module Sequencers
+  # Optional classes for MIDI {MTK::IO::File} and realtime MIDI {MTK::IO::Input} and {MTK::IO::Output}.
+  module IO
   end
 
   # Optional classes for the "MTK language", which let's you compose music via MTK without writing any Ruby code
   module Lang
   end
 
-  # Optional classes for MIDI input and {Output}.
-  module MIDI
+  # Classes that emit elements one at a time. Used by {MTK::Sequencers::Sequencer}s to construct {MTK::Events::Timeline}s.
+  module Patterns
   end
 
-end
-
-require 'mtk/pitch_class'
-require 'mtk/pitch'
-require 'mtk/duration'
-require 'mtk/intensity'
-
-require 'mtk/interval'
+  # Classes that assemble {MTK::Patterns::Pattern}s into {MTK::Events::Timeline}s.
+  module Sequencers
+  end
 
-require 'mtk/variable'
+end
 
-require 'mtk/helpers/collection'
-require 'mtk/helpers/pitch_collection'
-require 'mtk/helpers/pseudo_constants'
-require 'mtk/helpers/convert'
+require 'mtk/core/pitch_class'
+require 'mtk/core/pitch'
+require 'mtk/core/duration'
+require 'mtk/core/intensity'
+require 'mtk/core/interval'
+
+require 'mtk/lang/pseudo_constants'
+require 'mtk/lang/pitch_classes'
+require 'mtk/lang/pitches'
+require 'mtk/lang/intervals'
+require 'mtk/lang/intensities'
+require 'mtk/lang/durations'
+require 'mtk/lang/variable'
+require 'mtk/lang/parser'
 
-require 'mtk/pitch_class_set'
-require 'mtk/melody'
-require 'mtk/chord'
+require 'mtk/groups/collection'
+require 'mtk/groups/pitch_collection'
+require 'mtk/groups/pitch_class_set'
+require 'mtk/groups/melody'
+require 'mtk/groups/chord'
 
 require 'mtk/events/event'
 require 'mtk/events/note'
 require 'mtk/events/parameter'
-
-require 'mtk/timeline'
-
-require 'mtk/constants/pitch_classes'
-require 'mtk/constants/pitches'
-require 'mtk/constants/intervals'
-require 'mtk/constants/intensities'
-require 'mtk/constants/durations'
+require 'mtk/events/timeline'
 
 require 'mtk/patterns/pattern'
 require 'mtk/patterns/sequence'
@@ -78,5 +74,3 @@ require 'mtk/sequencers/sequencer'
 require 'mtk/sequencers/step_sequencer'
 require 'mtk/sequencers/rhythmic_sequencer'
 require 'mtk/sequencers/legato_sequencer'
-
-require 'mtk/lang/parser'

data/spec/mtk/{duration_spec.rb → core/duration_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MTK::Duration do
+describe MTK::Core::Duration do
 
   let(:one_beat)  { Duration[1] }
   let(:two_beats) { Duration[2] }
@@ -230,10 +230,10 @@ describe MTK::Duration do
   end
 
   describe '#inspect' do
-    it 'is "#<MTK::Duration:{object_id} @value={value}>"' do
+    it 'is "#<MTK::Core::Duration:{object_id} @value={value}>"' do
       for value in [0, 60, 60.5, 127]
         duration = Duration.new(value)
-        duration.inspect.should == "#<MTK::Duration:#{duration.object_id} @value=#{value}>"
+        duration.inspect.should == "#<MTK::Core::Duration:#{duration.object_id} @value=#{value}>"
       end
     end
   end

data/spec/mtk/{intensity_spec.rb → core/intensity_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MTK::Intensity do
+describe MTK::Core::Intensity do
 
   let(:half_intensity)  { Intensity[0.5] }
 
@@ -147,10 +147,10 @@ describe MTK::Intensity do
   end
 
   describe '#inspect' do
-    it 'is "#<MTK::Intensity:{object_id} @value={value}>"' do
+    it 'is "#<MTK::Core::Intensity:{object_id} @value={value}>"' do
       for value in [0, 60, 60.5, 127]
         intensity = Intensity.new(value)
-        intensity.inspect.should == "#<MTK::Intensity:#{intensity.object_id} @value=#{value}>"
+        intensity.inspect.should == "#<MTK::Core::Intensity:#{intensity.object_id} @value=#{value}>"
       end
     end
   end

data/spec/mtk/{interval_spec.rb → core/interval_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MTK::Interval do
+describe MTK::Core::Interval do
 
   let(:minor_second)  { Interval[1] }
 

data/spec/mtk/{pitch_class_spec.rb → core/pitch_class_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MTK::PitchClass do
+describe MTK::Core::PitchClass do
 
   let(:enharmonic_spellings_grouped_by_value) {
     # not sure how to test this without re-coding these names here

data/spec/mtk/{pitch_spec.rb → core/pitch_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MTK::Pitch do
+describe MTK::Core::Pitch do
 
   let(:middle_c) { Pitch.new(C, 4) }
   let(:lowest) { Pitch.new(C, -1) }
@@ -16,7 +16,7 @@ describe MTK::Pitch 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
+    it "can handle any type for the first argument that's supported by MTK::Core::PitchClass()" do
       Pitch['C',4].should == Pitch[0, 4]
     end
   end
@@ -83,9 +83,9 @@ describe MTK::Pitch do
     end
   end
 
-  describe ".from_hash" do
+  describe ".from_h" do
     it "constructs a Pitch from a hash of pitch attributes" do
-      Pitch.from_hash({:pitch_class => C, :octave => 4, :offset => 0.5}).should == middle_c_and_50_cents
+      Pitch.from_h({:pitch_class => C, :octave => 4, :offset => 0.5}).should == middle_c_and_50_cents
     end
   end
 
@@ -105,9 +105,9 @@ describe MTK::Pitch do
     end
   end
 
-  describe "#to_hash" do
+  describe "#to_h" do
     it "converts to a Hash" do
-      middle_c_and_50_cents.to_hash.should == {:pitch_class => C, :octave => 4, :offset => 0.5}
+      middle_c_and_50_cents.to_h.should == {:pitch_class => C, :octave => 4, :offset => 0.5}
     end
   end
 
@@ -142,10 +142,10 @@ describe MTK::Pitch do
   end
 
   describe '#inspect' do
-    it 'is "#<MTK::Pitch:{object_id} @value={value}>"' do
+    it 'is "#<MTK::Core::Pitch:{object_id} @value={value}>"' do
       for value in [0, 60, 60.5, 127]
         pitch = Pitch.from_f(value)
-        pitch.inspect.should == "#<MTK::Pitch:#{pitch.object_id} @value=#{value}>"
+        pitch.inspect.should == "#<MTK::Core::Pitch:#{pitch.object_id} @value=#{value}>"
       end
     end
   end

data/spec/mtk/events/event_spec.rb

@@ -166,15 +166,15 @@ describe MTK::Events::Event do
     end
   end
 
-  describe "from_hash" do
+  describe "from_h" do
     it "constructs an Event using a hash" do
-      EVENT.from_hash(hash).should == event
+      EVENT.from_h(hash).should == event
     end
   end
 
-  describe "#to_hash" do
+  describe "#to_h" do
     it "is a hash containing all the attributes of the Event" do
-      event.to_hash.should == hash
+      event.to_h.should == hash
     end
   end
 

data/spec/mtk/events/note_spec.rb

@@ -52,9 +52,9 @@ describe MTK::Events::Note do
     end
   end
 
-  describe ".from_hash" do
+  describe ".from_h" do
     it "constructs a Note using a hash" do
-      NOTE.from_hash({ :pitch => pitch, :intensity => intensity, :duration => duration }).should == note
+      NOTE.from_h({ :pitch => pitch, :intensity => intensity, :duration => duration }).should == note
     end
   end
 
@@ -64,9 +64,9 @@ describe MTK::Events::Note do
     end
   end
 
-  describe "#to_hash" do
+  describe "#to_h" do
     it "is a hash containing all the attributes of the Note" do
-      hash = note.to_hash
+      hash = note.to_h
       # hash includes some extra "baggage" for compatibility with AbstractEvent,
       # so we'll just check the fields we care about:
       hash[:pitch].should == pitch
@@ -125,8 +125,8 @@ describe MTK::Events::Note do
 
   describe "#inspect" do
     it 'is "#<MTK::Events::Note:{object_id} @pitch={pitch.inspect}, @duration={duration.inspect}, @intensity={intensity.inspect}>"' do
-      duration = MTK::Duration(1/8.0)
-      intensity = MTK::Intensity(1/8.0)
+      duration = MTK.Duration(1/8.0)
+      intensity = MTK.Intensity(1/8.0)
       note = NOTE.new(C4, duration, intensity)
       note.inspect.should == "#<MTK::Events::Note:#{note.object_id} @pitch=#{C4.inspect}, @duration=#{duration.inspect}, @intensity=#{intensity.inspect}>"
     end
@@ -161,11 +161,11 @@ describe MTK do
     end
 
     it "fills in a missing duration type from an number" do
-      Note(C4,mf,5.25).should == NOTE.new(C4,MTK::Duration(5.25),mf)
+      Note(C4,mf,5.25).should == NOTE.new(C4,MTK.Duration(5.25),mf)
     end
 
     it '' do
-      Note(MTK::Constants::Pitches::C4, MTK::Constants::Intensities::o, 5.25).should == Note(C4, 5.25, 0.75)
+      Note(MTK::Lang::Pitches::C4, MTK::Lang::Intensities::o, 5.25).should == Note(C4, 5.25, 0.75)
     end
 
   end

data/spec/mtk/{timeline_spec.rb → events/timeline_spec.rb}

@@ -1,15 +1,15 @@
 require 'spec_helper'
 
-describe MTK::Timeline do
+describe MTK::Events::Timeline do
 
   let(:note1) { Note(C4, p, 1) }
   let(:note2) { Note(G4, o, 2) }
   let(:timeline_raw_data) { { 0.0 => note1, 1.0 => [note1, note2] } }
   let(:timeline_hash) { { 0.0 => [note1], 1.0 => [note1, note2] } }
-  let(:timeline) { Timeline.from_hash(timeline_raw_data) }
+  let(:timeline) { MTK::Events::Timeline.from_h(timeline_raw_data) }
 
   let(:unquantized_data) { { 0.0 => [note1], 0.7 => [note1], 1.1 => [note2], 1.24 => [note1], 1.25 => [note1] } }
-  let(:unquantized_timeline) { Timeline.from_hash(unquantized_data) }
+  let(:unquantized_timeline) { MTK::Events::Timeline.from_h(unquantized_data) }
   let(:quantization_interval) { 0.5 }
   let(:quantized_data) { { 0.0 => [note1], 0.5 => [note1], 1.0 => [note2, note1], 1.5 => [note1] } }
 
@@ -18,26 +18,26 @@ describe MTK::Timeline do
   let(:shift_amount) { 5 }
 
   it "is Enumerable" do
-    Timeline.new.should be_a Enumerable
+    MTK::Events::Timeline.new.should be_a Enumerable
   end
 
   it "wraps lone values in arrays" do
-    Timeline.from_hash(timeline_raw_data).should == Timeline.from_hash(timeline_hash)
+    MTK::Events::Timeline.from_h(timeline_raw_data).should == MTK::Events::Timeline.from_h(timeline_hash)
   end
 
-  describe "from_hash" do
+  describe "from_h" do
     it "creates an empty timeline when the hash is empty" do
-      Timeline.from_hash({}).should be_empty
+      MTK::Events::Timeline.from_h({}).should be_empty
     end
 
     it "builds a Timeline from a map of times to single events" do
-      t = Timeline.from_hash({ 0 => note1, 1 => note2 })
+      t = MTK::Events::Timeline.from_h({ 0 => note1, 1 => note2 })
       t[0].should == [note1]
       t[1].should == [note2]
     end
 
     it "builds a Timeline from a map of times to event lists" do
-      t = Timeline.from_hash({ 0 => [note1, note2], 1 => [note2] })
+      t = MTK::Events::Timeline.from_h({ 0 => [note1, note2], 1 => [note2] })
       t[0].should == [note1, note2]
       t[1].should == [note2]
     end
@@ -45,13 +45,13 @@ describe MTK::Timeline do
 
   describe "from_a" do
     it "creates a timeline from an Enumerable" do
-      Timeline.from_a(timeline_hash.to_a).should == timeline
+      MTK::Events::Timeline.from_a(timeline_hash.to_a).should == timeline
     end
   end
 
-  describe "#to_hash" do
+  describe "#to_h" do
     it "returns the underlying Hash" do
-      timeline.to_hash.should == timeline_hash
+      timeline.to_h.should == timeline_hash
     end
   end
 
@@ -63,13 +63,13 @@ describe MTK::Timeline do
 
   describe "#merge" do
     it "merges all the time,event pairs in the given Enumerable into this Timeline" do
-      timeline.merge({ 3 => note2 }).should == Timeline.from_hash( timeline_raw_data.merge({ 3 => note2 }) )
+      timeline.merge({ 3 => note2 }).should == MTK::Events::Timeline.from_h( timeline_raw_data.merge({ 3 => note2 }) )
     end
   end
 
   describe "#empty?" do
     it "is true when the timeilne has no events" do
-      Timeline.new.empty?.should be_true
+      MTK::Events::Timeline.new.empty?.should be_true
     end
   end
 
@@ -109,7 +109,7 @@ describe MTK::Timeline do
     end
 
     it "coerces the argument to floating point for consistent lookup behavior" do
-      timeline = Timeline.new
+      timeline =  MTK::Events::Timeline.new
       timeline[nil] = note1
       timeline[1] = note1
       timeline[Rational(3,2)] = note1
@@ -136,7 +136,7 @@ describe MTK::Timeline do
     end
 
     it "coerces the argument to floating point for consistent lookup behavior" do
-      timeline = Timeline.new
+      timeline =  MTK::Events::Timeline.new
       timeline.add(nil, note1)
       timeline.add(1, note1)
       timeline.add(Rational(3,2), note1)
@@ -174,14 +174,14 @@ describe MTK::Timeline do
   describe "length" do
     it "is the lastest time + the longest duration of events at that time" do
       len = timeline.length
-      len.should be_a ::MTK::Duration
+      len.should be_a ::MTK::Core::Duration
       len.should == ::MTK.Duration(3)
     end
   end
 
   describe "empty?" do
     it "is true when there are no events in the timeline" do
-      Timeline.new.empty?.should be_true
+       MTK::Events::Timeline.new.empty?.should be_true
     end
 
     it "is false where there are events in the timeline" do
@@ -191,10 +191,10 @@ describe MTK::Timeline do
 
   describe "#==" do
     it "is true when the underlying Hashes are equal" do
-      timeline.should == Timeline.from_hash(timeline_hash)
+      timeline.should ==  MTK::Events::Timeline.from_h(timeline_hash)
     end
     it "is false when the underlying Hashes are not equal" do
-      timeline.should_not == Timeline.from_hash( {0 => [note2], 1 => [note1, note2]} )
+      timeline.should_not ==  MTK::Events::Timeline.from_h( {0 => [note2], 1 => [note1, note2]} )
     end
     it "allows for direct comparison to hashes" do
       timeline.should == timeline_hash
@@ -216,13 +216,13 @@ describe MTK::Timeline do
   end
 
   describe "#map" do
-    it "returns a new Timeline where each [time,event] pair is replaced by the result of block" do
+    it "returns a new  MTK::Events::Timeline where each [time,event] pair is replaced by the result of block" do
       mapped = timeline.map{|time,events| [time+1, events.map{|e| e.transpose(time+2) }] }
       mapped.should == { 1.0 => [note1.transpose(2)], 2.0 => [note1.transpose(3), note2.transpose(3)] }
     end
 
     it "handle events from different times being mapped to the same time" do
-      timeline = MTK::Timeline.from_hash({ 0.0 => [note1], 1.0 => [note1], 2.0 => [note2] })
+      timeline = MTK::Events::Timeline.from_h({ 0.0 => [note1], 1.0 => [note1], 2.0 => [note2] })
       mapped = timeline.map do |time,events|
         if events == [note1]
           [1.0, events]
@@ -233,33 +233,33 @@ describe MTK::Timeline do
       mapped.should == { 1.0 => [note1,note1], 2.0 => [note2] }
     end
 
-    it "does not modify this Timeline" do
+    it "does not modify this  MTK::Events::Timeline" do
       timeline.map{|t,e| [0,nil] }
       timeline.should == timeline_hash
     end
   end
 
   describe "#map!" do
-    it "maps the Timeline in place" do
+    it "maps the  MTK::Events::Timeline in place" do
       timeline.map! {|time,events| [time+1, events.map{|e| e.transpose(time+2) }] }
       timeline.should == { 1.0 => [note1.transpose(2)], 2.0 => [note1.transpose(3), note2.transpose(3)] }
     end
   end
 
   describe "#map_events" do
-    it "maps the Timeline in place" do
+    it "maps the  MTK::Events::Timeline in place" do
       mapped = timeline.map_events {|event| event.transpose(1) }
       mapped.should == { 0.0 => [note1.transpose(1)], 1.0 => [note1.transpose(1), note2.transpose(1)] }
     end
 
-    it "does not modify this Timeline" do
+    it "does not modify this  MTK::Events::Timeline" do
       timeline.map_events {|event| event.transpose(1) }
       timeline.should == timeline_hash
     end
   end
 
   describe "#map_events!" do
-    it "maps the Timeline in place" do
+    it "maps the  MTK::Events::Timeline in place" do
       timeline.map_events! {|event| event.transpose(1.0) }
       timeline.should == { 0.0 => [note1.transpose(1)], 1.0 => [note1.transpose(1), note2.transpose(1)] }
     end
@@ -278,7 +278,7 @@ describe MTK::Timeline do
     it "maps all times to the nearest multiple of the given interval" do
       unquantized_timeline.quantize(quantization_interval).should == quantized_data
     end
-    it "returns a new Timeline and does not modify the original" do
+    it "returns a new  MTK::Events::Timeline and does not modify the original" do
       unquantized_timeline.quantize(quantization_interval)
       unquantized_timeline.should == unquantized_data
     end
@@ -289,7 +289,7 @@ describe MTK::Timeline do
       unquantized_timeline.quantize!(quantization_interval).should == quantized_data
     end
 
-    it "modifies the Timeline in place" do
+    it "modifies the  MTK::Events::Timeline in place" do
       unquantized_timeline.quantize!(quantization_interval)
       unquantized_timeline.should == quantized_data
     end
@@ -308,7 +308,7 @@ describe MTK::Timeline do
       timeline.shift(shift_amount).should be_a timeline.class
     end
 
-    it "returns a new Timeline and does not modify the original" do
+    it "returns a new  MTK::Events::Timeline and does not modify the original" do
       timeline.shift(shift_amount).should_not equal timeline
     end
   end
@@ -329,23 +329,23 @@ describe MTK::Timeline do
 
   describe "#shift_to" do
     it "shifts so the start is at the given time" do
-      Timeline.from_hash(shifted_data).shift_to(0).should == timeline
-      Timeline.from_hash(reverse_shifted_data).shift_to(0).should == timeline
+       MTK::Events::Timeline.from_h(shifted_data).shift_to(0).should == timeline
+       MTK::Events::Timeline.from_h(reverse_shifted_data).shift_to(0).should == timeline
     end
 
     it "returns an instance of the same type" do
       timeline.shift_to(shift_amount).should be_a timeline.class
     end
 
-    it "returns a new Timeline and does not modify the original" do
+    it "returns a new  MTK::Events::Timeline and does not modify the original" do
       timeline.shift_to(shift_amount).should_not equal timeline
     end
   end
 
   describe "#shift_to!" do
     it "shifts so the start is at the given time" do
-      Timeline.from_hash(shifted_data).shift_to!(0).should == timeline
-      Timeline.from_hash(reverse_shifted_data).shift_to!(0).should == timeline
+       MTK::Events::Timeline.from_h(shifted_data).shift_to!(0).should == timeline
+       MTK::Events::Timeline.from_h(reverse_shifted_data).shift_to!(0).should == timeline
     end
 
     it "modifies the timeline in place" do
@@ -355,28 +355,28 @@ describe MTK::Timeline do
 
   describe "#flatten" do
     it "flattens nested timelines so that all nested subtimes are converted to absolute times in a single timeline" do
-      timeline[10] = Timeline.from_hash({ 0 => note2, 1 => note1 })
+      timeline[10] =  MTK::Events::Timeline.from_h({ 0 => note2, 1 => note1 })
       timeline.flatten.should == timeline_hash.merge({ 10.0 => [note2], 11.0 => [note1] })
     end
     
     it "handles nested timelines which have nested timelines inside of them" do
-      nested = Timeline.from_hash({ 0 => note1 })
-      timeline[10] = Timeline.from_hash({ 100 => nested })
+      nested =  MTK::Events::Timeline.from_h({ 0 => note1 })
+      timeline[10] =  MTK::Events::Timeline.from_h({ 100 => nested })
       timeline.flatten.should == timeline_hash.merge({ 110.0 => [note1] })
     end
 
     it "handles multiple nested timeslines at the same time point" do
-      timeline[10] = [Timeline.from_hash({ 0 => note2, 1 => note1 }), Timeline.from_hash({ 2 => note1, 3 => note2 })]
+      timeline[10] = [ MTK::Events::Timeline.from_h({ 0 => note2, 1 => note1 }),  MTK::Events::Timeline.from_h({ 2 => note1, 3 => note2 })]
       timeline.flatten.should == timeline_hash.merge({ 10.0 => [note2], 11.0 => [note1], 12.0 => [note1], 13.0 => [note2] })
     end
     
-    it "returns a new Timeline" do
+    it "returns a new  MTK::Events::Timeline" do
       timeline.flatten.should_not equal(timeline)
     end
   end
 
   describe "#clone" do
-    it "creates an equal Timeline" do
+    it "creates an equal  MTK::Events::Timeline" do
       timeline.clone.should == timeline
     end
 
@@ -387,17 +387,17 @@ describe MTK::Timeline do
 
   describe ".quantize_time" do
     it "takes a time and an interval, and returns the nearest multiple of the interval to the time" do
-      Timeline.quantize_time(23,10).should == 20
-      Timeline.quantize_time(27,10).should == 30
-      Timeline.quantize_time(30,10).should == 30
+       MTK::Events::Timeline.quantize_time(23,10).should == 20
+       MTK::Events::Timeline.quantize_time(27,10).should == 30
+       MTK::Events::Timeline.quantize_time(30,10).should == 30
     end
 
     it "rounds up when exactly between 2 intervals" do
-      Timeline.quantize_time(25,10).should == 30
+       MTK::Events::Timeline.quantize_time(25,10).should == 30
     end
 
     it "handles fractional intervals" do
-      Timeline.quantize_time(13,2.5).should == 12.5
+       MTK::Events::Timeline.quantize_time(13,2.5).should == 12.5
     end
   end
 
@@ -414,7 +414,7 @@ describe MTK::Timeline do
 
     it "pretty prints the output by aligning all '=>' arrows" do
       # alignment is only a factor when the times have different numbers of digits:
-      timeline = Timeline.new
+      timeline =  MTK::Events::Timeline.new
       timeline.add 0, note1
       timeline.add 10, note1
       timeline.add 1000, note1