mtk 0.0.2 → 0.0.3

data/lib/mtk/{sequencer → sequencers}/step_sequencer.rb

@@ -1,8 +1,8 @@
 module MTK
-  module Sequencer
+  module Sequencers
 
     # A Sequencer which has a constant {#step_size} time between {Timeline} entries.
-    class StepSequencer < AbstractSequencer
+    class StepSequencer < Sequencer
 
       # The time between entries in the {Timeline}.
       attr_accessor :step_size
@@ -15,8 +15,8 @@ module MTK
      ########################
       protected
 
-      # (see AbstractSequencer#advance!)
-      def advance!
+      # (see Sequencer#advance)
+      def advance
         @time += @step_size
       end
 

data/lib/mtk/timeline.rb

@@ -2,13 +2,12 @@ module MTK
 
   # A collection of timed events. The core data structure used to interface with input and output.
   #
-  # Maps sorted times to lists of events.
+  # Maps sorted floating point times to lists of events.
   #
   # Enumerable as [time,event_list] pairs.
   #
   class Timeline
-
-    include Transform::Mappable
+    include Enumerable
 
     def initialize()
       @timeline = {}
@@ -22,7 +21,7 @@ module MTK
     end
 
     def merge enumerable
-      for time,events in enumerable
+      enumerable.each do |time,events|
         add(time,events)
       end
       self
@@ -43,23 +42,23 @@ module MTK
     end
 
     def [](time)
-      @timeline[time]
+      @timeline[time.to_f]
     end
 
     def []=(time, events)
       time = time.to_f unless time.is_a? Numeric
       case events
         when nil?
-          @timeline.delete time
+          @timeline.delete time.to_f
         when Array
-          @timeline[time] = events
+          @timeline[time.to_f] = events
         else
-          @timeline[time] = [events]
+          @timeline[time.to_f] = [events]
       end
     end
 
     def add(time, event)
-      events = @timeline[time]
+      events = @timeline[time.to_f]
       if events
         if event.is_a? Array
           events.concat event
@@ -72,17 +71,23 @@ module MTK
     end
 
     def delete(time)
-      @timeline.delete(time)
+      @timeline.delete(time.to_f)
     end
 
     def has_time? time
-      @timeline.has_key? time
+      @timeline.has_key? time.to_f
     end
 
     def times
       @timeline.keys.sort
     end
 
+    def length
+      last_time = times.last
+      events = @timeline[last_time]
+      last_time + events.map{|event| event.duration }.max
+    end
+
     def empty?
       @timeline.empty?
     end
@@ -93,15 +98,24 @@ module MTK
 
     def each
       # this is similar to @timeline.each, but by iterating over #times, we yield the events in chronological order
-      for time in times
-        yield time,@timeline[time]
+      times.each do |time|
+        yield time, @timeline[time]
       end
     end
 
+    # the original Enumerable#map implementation, which returns an Array
+    alias enumerable_map map
+
+    # Constructs a new Timeline by mapping each [time,event_list] pair
+    # @see #map!
+    def map &block
+      self.class.from_a enumerable_map(&block)
+    end
+
+    # Perform #map in place
+    # @see #map
     def map! &block
-      # we use the enumerable_map that aliased by the Mappable module,
-      # because Mappable#map will create an extra timeline instance, which is unnecessary in this case
-      mapped = enumerable_map &block
+      mapped = enumerable_map(&block)
       clear
       merge mapped
     end
@@ -109,7 +123,7 @@ module MTK
     # Map every individual event, without regard for the time at which is occurs
     def map_events
       mapped_timeline = Timeline.new
-      for time,events in self
+      self.each do |time,events|
         mapped_timeline[time] = events.map{|event| yield event }
       end
       mapped_timeline
@@ -117,7 +131,7 @@ module MTK
 
     # Map every individual event in place, without regard for the time at which is occurs
     def map_events!
-      for time,events in self
+      each do |time,events|
         self[time] = events.map{|event| yield event }
       end
     end
@@ -132,10 +146,10 @@ module MTK
     
     def flatten
       flattened = Timeline.new
-      for time,events in self
-        for event in events
+      self.each do |time,events|
+        events.each do |event|
           if event.is_a? Timeline
-            for subtime,subevent in event.flatten
+            event.flatten.each do |subtime,subevent|
               flattened.add(time+subtime, subevent)
             end
           else
@@ -195,7 +209,10 @@ module MTK
     end
 
     def to_s
-      times.map{|t| "#{t} => #{@timeline[t].join ', '}" }.join "\n"
+      times = self.times
+      last = times.last
+      width = sprintf("%d",last).length + 3 # nicely align the '=>' against the longest number
+      times.map{|t| sprintf("%#{width}.2f",t)+" => #{@timeline[t].join ', '}" }.join "\n"
     end
 
     def inspect

data/lib/mtk/variable.rb

@@ -0,0 +1,32 @@
+module MTK
+
+  # A placeholder element for a variable value, for use within a {Patterns::Pattern} such as a {Patterns::ForEach} pattern.
+  # Will be evaluated to an actual value by the Pattern or Sequencer
+  #
+  class Variable
+
+    attr_reader :name
+
+    attr_accessor :value
+
+    def initialize name, value=nil
+      @name = name
+      @value = value
+      @implicit = !!(name =~ /^\$+$/)
+    end
+
+    # @return true when this variable has no specific value and references the implicit variable stack (such as in a {Patterns::ForEach})
+    def implicit?
+      @implicit
+    end
+
+    def == other
+      other.is_a? self.class and other.name == self.name
+    end
+
+    def to_s
+      "#{self.class}<#{name}#{'='+value.to_s if value}>"
+    end
+  end
+
+end

data/spec/mtk/chord_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe MTK::Chord do
+
+  let(:c_major) { Chord.new([C4,E4,G4]) }
+
+  describe ".new" do
+    it "removes duplicates" do
+      Chord.new([C4, E4, G4, C4]).pitches.should == [C4, E4, G4]
+    end
+
+    it "sorts the pitches" do
+      Chord.new([F4, G4, E4, D4, C4]).pitches.should == [C4, D4, E4, F4, G4]
+    end
+  end
+
+  describe '#inversion' do
+    it "adds an octave to the chord's pitches starting from the lowest, for each whole number in a postive argument" do
+      c_major.inversion(2).should == Chord.new([G4,C5,E5])
+    end
+
+    it "subtracts an octave to the chord's pitches starting fromt he highest, for each whole number in a negative argument" do
+      c_major.inversion(-2).should == Chord.new([E3,G3,C4])
+    end
+
+    it "wraps around to the lowest pitch when the argument is bigger than the number of pitches in the chord (positive argument)" do
+      c_major.inversion(4).should == Chord.new([E5,G5,C6])
+    end
+
+    it "wraps around to the highest pitch when the magnitude of the argument is bigger than the number of pitches in the chord (negative argument)" do
+      c_major.inversion(-4).should == Chord.new([G2,C3,E3])
+    end
+  end
+
+  describe "#nearest" do
+    it "returns the nearest Melody where the first Pitch has the given PitchClass" do
+      c_major.nearest(F).should == c_major.transpose(5)
+      c_major.nearest(G).should == c_major.transpose(-5)
+    end
+  end
+
+end
+
+describe MTK do
+
+  describe '#Chord' do
+
+    it "acts like new for a single Array argument" do
+      Chord([C4,D4]).should == Chord.new([C4,D4])
+    end
+
+    it "acts like new for multiple arguments, by treating them like an Array (splat)" do
+      Chord(C4,D4).should == Chord.new([C4,D4])
+    end
+
+    it "handles an Array with elements that can be converted to Pitches" do
+      Chord(['C4','D4']).should == Chord.new([C4,D4])
+    end
+
+    it "handles multiple arguments that can be converted to a Pitch" do
+      Chord(:C4,:D4).should == Chord.new([C4,D4])
+    end
+
+    it "handles a single Pitch" do
+      Chord(C4).should == Chord.new([C4])
+    end
+
+    it "handles single elements that can be converted to a Pitch" do
+      Chord('C4').should == Chord.new([C4])
+    end
+
+    it "returns the argument if it's already a Chord" do
+      pitch_set = Chord.new([C4,D4,D4])
+      Chord(pitch_set).should == Chord.new([C4,D4])
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ Chord({:not => :compatible}) }.should raise_error
+    end
+
+  end
+
+end

data/spec/mtk/{_constants → constants}/durations_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe MTK::Durations do
+describe MTK::Constants::Durations do
 
   describe 'w' do
     it 'is 4 beats' do
-      w.should == 4
+      w.value.should == 4
     end
     it 'is available via a module property and via mixin' do
       Durations::w.should == w
@@ -13,7 +13,7 @@ describe MTK::Durations do
 
   describe 'h' do
     it 'is 2 beats' do
-      h.should == 2
+      h.value.should == 2
     end
     it 'is available via a module property and via mixin' do
       Durations::h.should == h
@@ -22,25 +22,25 @@ describe MTK::Durations do
 
   describe 'q' do
     it 'is 1 beat' do
-      q.round.should == 1
+      q.value.should == 1
     end
     it 'is available via a module property and via mixin' do
       Durations::q.should == q
     end
   end
 
-  describe 'e' do
+  describe 'i' do
     it 'is 1/2 of a beat' do
-      e.should == 1.0/2
+      i.value.should == 1.0/2
     end
     it 'is available via a module property and via mixin' do
-      Durations::e.should == e
+      Durations::i.should == i
     end
   end
 
   describe 's' do
     it 'is 1/4 of a beat' do
-      s.should == 1.0/4
+      s.value.should == 1.0/4
     end
     it 'is available via a module property and via mixin' do
       Durations::s.should == s
@@ -49,7 +49,7 @@ describe MTK::Durations do
 
   describe 'r' do
     it 'is 1/8 of a beat' do
-      r.should == 1.0/8
+      r.value.should == 1.0/8
     end
     it 'is available via a module property and via mixin' do
       Durations::r.should == r
@@ -58,7 +58,7 @@ describe MTK::Durations do
 
   describe 'x' do
     it 'is 1/16 of a beat' do
-      x.should == 1.0/16
+      x.value.should == 1.0/16
     end
     it 'is available via a module property and via mixin' do
       Durations::x.should == x
@@ -67,7 +67,7 @@ describe MTK::Durations do
 
   describe "DURATIONS" do
     it "contains all Durations pseudo-constants" do
-      Durations::DURATIONS.should =~ [w, h, q, e, s, r, x]
+      Durations::DURATIONS.should =~ [w, h, q, i, s, r, x]
     end
 
     it "is immutable" do
@@ -77,7 +77,7 @@ describe MTK::Durations do
 
   describe "DURATION_NAMES" do
     it "contains all Durations pseudo-constants names as strings" do
-      Durations::DURATION_NAMES.should =~ ['w', 'h', 'q', 'e', 's', 'r', 'x']
+      Durations::DURATION_NAMES.should =~ ['w', 'h', 'q', 'i', 's', 'r', 'x']
     end
 
     it "is immutable" do
@@ -85,34 +85,5 @@ describe MTK::Durations do
     end
   end
 
-  describe ".[]" do
-    it "looks up the constant by name" do
-      for duration in Durations::DURATION_NAMES
-        Durations[duration].should == Durations.send(duration)
-      end
-    end
-
-    it "supports a '.' suffix, which multiples the value by 1.5" do
-      for duration in Durations::DURATION_NAMES
-        Durations["#{duration}."].should == Durations.send(duration) * 1.5
-      end
-    end
-
-    it "supports a 't' suffix, which multiples the value by 2/3" do
-      for duration in Durations::DURATION_NAMES
-        Durations["#{duration}t"].should == Durations.send(duration) * 2/3.0
-      end
-    end
-
-    it "supports '.' and 't' suffixes in any combination" do
-      for duration in Durations::DURATION_NAMES
-        Durations["#{duration}.t"].should == Durations.send(duration) * 1.5 * 2/3.0
-        Durations["#{duration}t."].should == Durations.send(duration) * 1.5 * 2/3.0
-        Durations["#{duration}.."].should == Durations.send(duration) * 1.5 * 1.5
-        Durations["#{duration}..t.t."].should == Durations.send(duration) * 1.5**4 * (2/3.0)**2
-      end
-    end
-  end
-
 end
 

data/spec/mtk/{_constants → constants}/intensities_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
   
-describe MTK::Intensities do
+describe MTK::Constants::Intensities do
 
   describe 'ppp' do
     it 'is equivalent to MIDI velocity 16' do
-      (ppp * 127).round.should == 16
+      (ppp.value * 127).round.should == 16
     end
     it 'is available via a module property and via mixin' do
       Intensities::ppp.should == ppp
@@ -13,7 +13,7 @@ describe MTK::Intensities do
 
   describe 'pp' do
     it 'is equivalent to MIDI velocity 32' do
-      (pp * 127).round.should == 32
+      (pp.value * 127).round.should == 32
     end
     it 'is available via a module property and via mixin' do
       Intensities::pp.should == pp
@@ -22,7 +22,7 @@ describe MTK::Intensities do
 
   describe 'p' do
     it 'is equivalent to MIDI velocity 48' do
-      (p * 127).round.should == 48
+      (p.value * 127).round.should == 48
     end
     it 'is available via a module property and via mixin' do
       Intensities::p.should == p
@@ -31,7 +31,7 @@ describe MTK::Intensities do
 
   describe 'mp' do
     it 'is equivalent to MIDI velocity 64' do
-      (mp * 127).round.should == 64
+      (mp.value * 127).round.should == 64
     end
     it 'is available via a module property and via mixin' do
       Intensities::mp.should == mp
@@ -40,19 +40,19 @@ describe MTK::Intensities do
 
   describe 'mf' do
     it 'is equivalent to MIDI velocity 79' do
-      (mf * 127).round.should == 79
+      (mf.value * 127).round.should == 79
     end
     it 'is available via a module property and via mixin' do
       Intensities::mf.should == mf
     end    
   end
 
-  describe 'f' do
+  describe 'o' do # AKA forte
     it 'is equivalent to MIDI velocity 95' do
-      (f * 127).round.should == 95
+      (o.value * 127).round.should == 95
     end
     it 'is available via a module property and via mixin' do
-      Intensities::f.should == f
+      Intensities::o.should == o
     end
     it "does not overwrite the PitchClass constant 'F'" do
       F.should be_a PitchClass
@@ -61,7 +61,7 @@ describe MTK::Intensities do
 
   describe 'ff' do
     it 'is equivalent to MIDI velocity 111' do
-      (ff * 127).round.should == 111
+      (ff.value * 127).round.should == 111
     end
     it 'is available via a module property and via mixin' do
       Intensities::ff.should == ff
@@ -70,7 +70,7 @@ describe MTK::Intensities do
 
   describe 'fff' do
     it 'is equivalent to MIDI velocity 127' do
-      (fff * 127).round.should == 127
+      (fff.value * 127).round.should == 127
     end
     it 'is available via a module property and via mixin' do
       Intensities::fff.should == fff
@@ -79,7 +79,7 @@ describe MTK::Intensities do
 
   describe "INTENSITIES" do
     it "contains all Intensities pseudo-constants" do
-      Intensities::INTENSITIES.should =~ [ppp, pp, p, mp, mf, f, ff, fff]
+      Intensities::INTENSITIES.should =~ [ppp, pp, p, mp, mf, o, ff, fff]
     end
 
     it "is immutable" do
@@ -89,7 +89,7 @@ describe MTK::Intensities do
 
   describe "INTENSITY_NAMES" do
     it "contains all Intensities pseudo-constants names as strings" do
-      Intensities::INTENSITY_NAMES.should =~ ['ppp', 'pp', 'p', 'mp', 'mf', 'f', 'ff', 'fff']
+      Intensities::INTENSITY_NAMES.should =~ ['ppp', 'pp', 'p', 'mp', 'mf', 'o', 'ff', 'fff']
     end
 
     it "is immutable" do
@@ -97,29 +97,5 @@ describe MTK::Intensities do
     end
   end
 
-  describe ".[]" do
-    it "looks up the constant by name" do
-      for name in INTENSITY_NAMES
-        Intensities[name].should == Intensities.send(name)
-      end
-    end
-
-    it "adds 1.0/24 when the name ends with '+', except for 'fff+' which is 1.0 like 'fff'" do
-      for name in INTENSITY_NAMES
-        if name == 'fff'
-          Intensities["#{name}+"].should == 1.0
-        else
-          Intensities["#{name}+"].should == Intensities.send(name)+1.0/24
-        end
-      end
-    end
-
-    it "subtracts 1.0/24 when the name ends with '-'" do
-      for name in INTENSITY_NAMES
-        Intensities["#{name}-"].should == Intensities.send(name)-1.0/24
-      end
-    end
-  end
-
 end