mtk 0.0.3.3 → 0.4

data/lib/mtk/lang/tutorial_lesson.rb

@@ -0,0 +1,87 @@
+module MTK
+  module Lang
+
+    # @private
+    class TutorialLesson
+
+      # Every TutorialLesson requires the options at construction title:
+      #   title - The short summary displayed in the tutorial's table of contents.
+      #   description - The full description displayed when entering the tutorial step.
+      #   validate(input) - Validate user input entered after the description is displayed.
+      #   success(input) - Perform an action on successful validation
+      #   failure(input) - Instruct the user on failed validation
+      def initialize options
+        @title = options[:title]
+        @description = options[:description].split("\n").map{|line| line.strip }.join("\n") # trim extra whitespace
+        @validation = options[:validation]
+      end
+
+
+      def run(output)
+        puts
+        puts Tutorial::SEPARATOR
+        puts
+        puts "Lesson: #{@title}".bold.yellow
+        puts @description
+        puts
+        print "Try it now: ".blue
+
+        did_it_once = false
+        input = gets.strip
+        until did_it_once and input.empty?
+          until validate(input)
+            failure(input)
+            print "Try again: ".blue
+            input = gets.strip
+          end
+
+          success(input, output)
+          did_it_once = true
+          puts
+          puts "Good! ".bold.green + "Try again, or press enter to exit this lesson:".blue
+          input = gets.strip
+        end
+      end
+
+
+      def validate(input)
+        return false if input.empty?
+
+        case @validation
+          when Symbol
+            MTK::Lang::Parser.parse(input, @validation)
+            true
+          else # Assume Regexp
+            (input =~ @validation) != nil and MTK::Lang::Parser.parse(input)
+        end
+      rescue Citrus::ParseError
+        false
+      end
+
+
+      def success(input, output)
+        sequencer = MTK::Lang::Parser.parse(input)
+        if sequencer
+          output.play sequencer.to_timeline
+        else
+          STDERR.puts "Nothing to play for \"#{input}\""
+        end
+      rescue Citrus::ParseError
+        STDERR.puts $!
+      end
+
+
+      def failure(input)
+        puts
+        puts "Invalid entry \"#{input}\"".bold.red
+      end
+
+
+      def to_s
+        @title
+      end
+
+    end
+
+  end
+end

data/lib/mtk/sequencers/event_builder.rb

@@ -29,15 +29,31 @@ module MTK
         @patterns.each do |pattern|
           pattern_value = pattern.next
 
-          elements = pattern_value.is_a?(Enumerable) ? pattern_value : [pattern_value]
+          elements = if pattern_value.is_a? Enumerable and not pattern_value.is_a? MTK::Groups::PitchCollection then
+            pattern_value
+          else
+            [pattern_value]
+          end
+
           elements.each do |element|
             return nil if element.nil? or element == :skip
 
             case element
-              when ::MTK::Core::Pitch         then pitches << element
-              when ::MTK::Core::PitchClass    then pitches += pitches_for_pitch_classes([element], @previous_pitch)
-              when ::MTK::Groups::PitchClassSet then pitches += pitches_for_pitch_classes(element, @previous_pitch)
-              when ::MTK::Groups::PitchCollection then pitches += element.pitches # this must be after the PitchClassSet case, because that is also a PitchCollection
+              when ::MTK::Core::Pitch
+                pitches << element
+                @previous_pitch = element
+
+              when ::MTK::Core::PitchClass
+                pitches += pitches_for_pitch_classes([element], @previous_pitch)
+                @previous_pitch = pitches.last
+
+              when ::MTK::Groups::PitchClassSet
+                pitches += pitches_for_pitch_classes(element, @previous_pitch)
+                @previous_pitch = pitches.last
+
+              when ::MTK::Groups::PitchCollection
+                pitches += element.pitches # this must be after the PitchClassSet case, because that is also a PitchCollection
+                @previous_pitch = pitches.last
 
               when ::MTK::Core::Duration
                 duration ||= 0
@@ -52,6 +68,7 @@ module MTK
                 else
                   pitches << (@previous_pitch + element)
                 end
+                @previous_pitch = pitches.last
 
               # TODO? String/Symbols for special behaviors like :skip, or :break (something like StopIteration for the current Pattern?)
 
@@ -62,7 +79,7 @@ module MTK
         end
 
         pitches     << @previous_pitch if pitches.empty?
-        duration   ||= @previous_duration
+        duration   ||= @previous_duration.abs
 
         if intensities.empty?
           intensity = @previous_intensity
@@ -80,7 +97,11 @@ module MTK
         @previous_intensity = intensity
         @previous_duration = duration
 
-        pitches.map{|pitch| MTK::Events::Note.new(pitch,duration,intensity,@channel) }
+        if duration.rest?
+          [MTK::Events::Rest.new(duration,@channel)]
+        else
+          pitches.map{|pitch| MTK::Events::Note.new(pitch,duration,intensity,@channel) }
+        end
       end
 
       # Reset the EventBuilder to its initial state
@@ -98,7 +119,7 @@ module MTK
       private
 
       def pitches_for_pitch_classes(pitch_classes, previous_pitch)
-        pitch_classes.map{|pitch_class| previous_pitch.nearest(pitch_class) }
+        pitch_classes.to_a.map{|pitch_class| previous_pitch.nearest(pitch_class) }
       end
 
       def constrain_pitch(pitches)

data/spec/mtk/core/duration_spec.rb

@@ -8,7 +8,7 @@ describe MTK::Core::Duration do
 
   describe 'NAMES' do
     it "is the list of base duration names available" do
-      Duration::NAMES.should =~ %w( w h q i s r x )
+      Duration::NAMES.should =~ %w( w h q e s r x )
     end
 
     it "is immutable" do
@@ -176,6 +176,19 @@ describe MTK::Core::Duration do
   end
 
 
+  describe '#abs' do
+    it 'returns the Duration is the value is positive' do
+      d = MTK.Duration(2)
+      d.abs.should be d
+    end
+
+    it 'returns the negation of the Duration is the value is negative' do
+      d = MTK.Duration(-2)
+      d.abs.should == -d
+    end
+  end
+
+
   describe '#to_f' do
     it "is the value as a floating point number" do
       f = Duration.new(Rational(1,2)).to_f

data/spec/mtk/core/intensity_spec.rb

@@ -7,7 +7,7 @@ describe MTK::Core::Intensity do
 
   describe 'NAMES' do
     it "is the list of base intensity names available" do
-      Intensity::NAMES.should =~ %w( ppp pp p mp mf o ff fff )
+      Intensity::NAMES.should =~ %w( ppp pp p mp mf f ff fff )
     end
 
     it "is immutable" do

data/spec/mtk/events/event_spec.rb

@@ -12,7 +12,7 @@ describe MTK::Events::Event do
 
 
   describe "#type" do
-    it "is the first argument passed to AbstractEvent.new" do
+    it "is the first argument passed to Event.new" do
       event.type.should == type
     end
 
@@ -22,7 +22,7 @@ describe MTK::Events::Event do
   end
 
   describe "#value" do
-    it "is the value of the :value key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :value key in the options hash passed to Event.new" do
       event.value.should == options[:value]
     end
 
@@ -39,7 +39,7 @@ describe MTK::Events::Event do
   end
 
   describe "#duration" do
-    it "is the value of the :duration key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :duration key in the options hash passed to Event.new" do
       event.duration.should == options[:duration]
     end
 
@@ -56,7 +56,7 @@ describe MTK::Events::Event do
   end
 
   describe "#number" do
-    it "is the value of the :number key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :number key in the options hash passed to Event.new" do
       event.number.should == options[:number]
     end
 
@@ -73,7 +73,7 @@ describe MTK::Events::Event do
   end
 
   describe "#channel" do
-    it "is the value of the :channel key in the options hash passed to AbstractEvent.new" do
+    it "is the value of the :channel key in the options hash passed to Event.new" do
       event.channel.should == options[:channel]
     end
 
@@ -155,17 +155,6 @@ describe MTK::Events::Event do
     end
   end
 
-  describe "#duration_in_pulses" do
-    it "multiplies the #length times the argument and rounds to the nearest integer" do
-      event.duration_in_pulses(111).should == (event.length * 111).round
-    end
-
-    it "is 0 when the #duration is nil" do
-      event.duration = nil
-      event.duration_in_pulses(111).should == 0
-    end
-  end
-
   describe "from_h" do
     it "constructs an Event using a hash" do
       EVENT.from_h(hash).should == event
@@ -187,6 +176,11 @@ describe MTK::Events::Event do
       EVENT.new(type, :duration => 1.5).duration_in_pulses(59).should == 89
     end
 
+    it "is 0 when the #duration is nil" do
+      event.duration = nil
+      event.duration_in_pulses(111).should == 0
+    end
+
     it "is always positive (uses absolute value of the duration used to construct the Event)" do
       EVENT.new(type, :duration => -1).duration_in_pulses(60).should == 60
     end

data/spec/mtk/events/note_spec.rb

@@ -160,12 +160,12 @@ describe MTK do
       Note(q,mf,C4).should == NOTE.new(C4,q,mf)
     end
 
-    it "fills in a missing duration type from an number" do
+    it "fills in a missing duration argument from an number" do
       Note(C4,mf,5.25).should == NOTE.new(C4,MTK.Duration(5.25),mf)
     end
 
-    it '' do
-      Note(MTK::Lang::Pitches::C4, MTK::Lang::Intensities::o, 5.25).should == Note(C4, 5.25, 0.75)
+    it 'fills in a missing intensity and duration arguments from numbers' do
+      Note(MTK::Lang::Pitches::C4, MTK::Lang::Intensities::f, 5.25).should == Note(C4, 5.25, 0.75)
     end
 
   end

data/spec/mtk/events/rest_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe MTK::Events::Rest do
+
+  REST = MTK::Events::Rest
+
+  let(:duration) { -7.5 }
+  let(:channel) { 3 }
+  let(:rest) { REST.new duration, channel }
+  let(:hash) { {type: :rest, duration: duration, channel: channel} }
+
+
+  describe ".new" do
+    it "requires a duration as the first argument" do
+      lambda{ REST.new() }.should raise_error
+    end
+
+    it "coerces the duration to an MTK::Core::Duration" do
+      rest.duration.should be_a MTK::Core::Duration
+    end
+
+    it "forces the duration value negative to be a rest, if needed" do
+      REST.new(5).duration.should == -5
+    end
+  end
+
+  describe "#type" do
+    it "is :rest" do
+      rest.type.should == :rest
+    end
+
+    it "is a read-only attribute" do
+      lambda{ rest.type = :anything }.should raise_error
+    end
+  end
+
+  describe "#duration" do
+    it "is the value of the first argument to Rest.new, if the value was negative (indicating a rest)" do
+      rest.duration.should == duration
+    end
+  end
+
+  describe "#duration=" do
+    it "sets #duration" do
+      rest.duration = -42
+      rest.duration.should == -42
+    end
+
+    it "forces coerces argument to a MTK::Core::Duration" do
+      rest.duration = 42
+      rest.duration.should be_a MTK::Core::Duration
+    end
+
+    it "forces the duration value negative to be a rest, if needed" do
+      rest.duration = 42
+      rest.duration.should == -42
+    end
+  end
+
+  describe "#channel" do
+    it "is the value of the :channel key in the options hash passed to Rest.new" do
+      rest.channel.should == channel
+    end
+
+    it "defaults to nil" do
+      REST.new(duration).channel.should be_nil
+    end
+  end
+
+  describe "#channel=" do
+    it "sets #channel" do
+      rest.channel = 12
+      rest.channel.should == 12
+    end
+  end
+
+  describe "#midi_value" do
+    it "is nil" do
+      rest.midi_value.should be_nil
+    end
+  end
+
+  describe "#length" do
+    it "is the absolute value of duration" do
+      rest.duration = -5
+      rest.length.should == 5
+    end
+  end
+
+  describe "#rest?" do
+    it "is true when the duration is negative" do
+      rest.rest?.should be_true
+    end
+
+    it "is true event with a positive duration, because the duration was forced negative" do
+      rest.duration = 5
+      rest.rest?.should be_true
+    end
+  end
+
+  describe "from_h" do
+    it "constructs an Event using a hash" do
+      REST.from_h(hash).should == rest
+    end
+  end
+
+  describe "#to_h" do
+    it "is a hash containing all the attributes of the Rest" do
+      rest.to_h.should == hash
+    end
+  end
+
+
+  describe "#==" do
+    it "is true when the duration and channel are equal" do
+      rest.should == REST.new(duration, channel)
+    end
+
+    it "is false when the durations are not equal" do
+      rest.should_not == REST.new(duration+1, channel)
+    end
+
+    it "is false when the channels are not equal" do
+      rest.should_not == REST.new(duration, channel+1)
+    end
+  end
+
+  describe "#to_s" do
+    it "includes #duration to 2 decimal places" do
+      REST.new(Duration(-1/3.0)).to_s.should == "Rest(-0.33 beat)"
+    end
+  end
+
+  describe "#inspect" do
+    it 'is "#<MTK::Events::Rest:{object_id} @duration={duration.inspect}, @channel={channel}>"' do
+      rest.inspect.should == "#<MTK::Events::Rest:#{rest.object_id} @duration=#{rest.duration.inspect}, @channel=#{channel}>"
+    end
+  end
+
+end
+
+
+describe MTK do
+
+  describe '#Rest' do
+
+    it "acts like new for multiple arguments" do
+      MTK::Rest(4,2).should == REST.new(4,2)
+    end
+
+    it "acts like new for an Array of arguments by unpacking (splatting) them" do
+      MTK::Rest([4,2]).should == REST.new(4,2)
+    end
+
+    it "returns the argument if it's already a Rest" do
+      rest = REST.new(4,2)
+      MTK::Rest(rest).should be_equal(rest)
+    end
+
+    it "makes a Rest of the same duration and channel from other Event types" do
+      event = MTK::Events::Event.new(:event_type, duration:5, channel:3)
+      MTK::Rest(event).should == REST.new(5,3)
+    end
+
+    it "handles a single Numeric argument" do
+      MTK::Rest(4).should == REST.new(4)
+    end
+
+    it "handles a single Duration argument" do
+      MTK.Rest(MTK.Duration(4)).should == REST.new(4)
+    end
+
+    it "raises an error for types it doesn't understand" do
+      lambda{ MTK::Rest({:not => :compatible}) }.should raise_error
+    end
+
+    it "handles out of order arguments for recognized Duration types" do
+      MTK::Rest(2,q).should == REST.new(q,2)
+    end
+
+  end
+
+end
+