midi-message 0.2.4 → 0.3.0

data/lib/midi-message.rb

@@ -5,33 +5,36 @@
 # 
 module MIDIMessage
   
+  module Event
+  end
+  
   module Process    
   end
   
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
  
 end
 
-require 'yaml'
-
-# messages
-
-require 'midi-message/short_message'
-require 'midi-message/channel_message'
-require 'midi-message/constant'
-require 'midi-message/context'
-require 'midi-message/note_message'
-require 'midi-message/parser'
-require 'midi-message/system_message'
-require 'midi-message/system_exclusive'
-require 'midi-message/type_conversion'
+# libs
+require "forwardable"
+require "yaml"
 
-# message processors
+# messages (mixed format)
+require "midi-message/short_message"
+require "midi-message/channel_message"
+require "midi-message/constant"
+require "midi-message/context"
+require "midi-message/note_message"
+require "midi-message/parser"
+require "midi-message/system_message"
+require "midi-message/system_exclusive"
+require "midi-message/type_conversion"
 
 # modules
 require "midi-message/process/processor"
 
 # classes
+require "midi-message/event/note"
 require "midi-message/process/filter"
 require "midi-message/process/limit"
 require "midi-message/process/transpose"

data/lib/midi-message/event/note.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+module MIDIMessage
+
+  module Event
+    
+    # an Event::Note is a pairing of a MIDI NoteOn and NoteOff message
+    # has a length that corresponds to sequencer ticks
+    class Note
+
+      extend Forwardable
+
+      attr_reader :start,
+                  :finish,
+                  :length
+                  
+      alias_method :duration, :length
+
+      def_delegators :start, :note
+      
+      def initialize(start_message, duration, options = {})
+        @start = start_message
+        @length = duration
+
+        @finish = options[:finish] || start_message.to_note_off
+      end
+
+    end
+    
+  end
+  
+end

data/lib/midi-message/process/filter.rb

@@ -11,45 +11,45 @@ module MIDIMessage
 
       attr_reader :bandwidth, :property, :reject
       
-      def initialize(message, prop, bandwidth, options = {})
+      def initialize(prop, bandwidth, options = {})
         @bandwidth = [bandwidth].flatten
-        @message = message
         @property = prop
         @reject = options[:reject] || false
-        initialize_processor(message)
+
+        initialize_processor(options)
       end
 
-      def process
-        val = @message.send(@property)
-        result = @bandwidth.map { |bw| val >= bw.min && val <= bw.max ? @message : nil }
-        result.include?(@message) ^ @reject ? @message : nil
+      def process_single(message)
+        val = message.send(@property)
+        result = @bandwidth.map { |bw| val >= bw.min && val <= bw.max ? message : nil }
+        result.include?(message) ^ @reject ? message : nil
       end
 
     end
 
     class LowPassFilter < Filter
-      def initialize(message, prop, max, options = {})
-        super(message, prop, (0..max), options)
+      def initialize(prop, max, options = {})
+        super(prop, (0..max), options)
       end
     end
 
     class HighPassFilter < Filter
-      def initialize(message, prop, min, options = {})
-        super(message, prop, (min..127), options)
+      def initialize(prop, min, options = {})
+        super(prop, (min..127), options)
       end
     end
 
     class BandPassFilter < Filter
-      def initialize(message, prop, accept_range, options = {})
+      def initialize(prop, accept_range, options = {})
         options[:reject] = false
-        super(message, prop, accept_range, options)
+        super(prop, accept_range, options)
       end
     end
 
     class BandRejectFilter < Filter
-      def initialize(message, prop, reject_range, options = {})
+      def initialize(prop, reject_range, options = {})
         options[:reject] = true
-        super(message, prop, reject_range, options)
+        super(prop, reject_range, options)
       end
     end
     NotchFilter = BandRejectFilter

data/lib/midi-message/process/limit.rb

@@ -8,20 +8,25 @@ module MIDIMessage
 
       include Processor
 
-      attr_reader :property, :range
+      attr_reader :property, :limit_to
+      alias_method :range, :limit_to
       
-      def initialize(message, prop, range, options = {})
-        @range = range
-        @message = message
+      def initialize(prop, limit_to, options = {})
+        @limit_to = limit_to
         @property = prop
-        initialize_processor(message)
+        
+        initialize_processor(options)
       end
 
-      def process
-        val = @message.send(@property)
-        @message.send("#{@property}=", @range.min) if val < @range.min
-        @message.send("#{@property}=", @range.max) if val > @range.max
-        @message
+      def process_single(message)
+        val = message.send(@property)
+        if @limit_to.kind_of?(Range)
+          message.send("#{@property}=", @limit_to.min) if val < @limit_to.min
+          message.send("#{@property}=", @limit_to.max) if val > @limit_to.max
+        elsif @limit_to.kind_of?(Numeric)
+          message.send("#{@property}=", @limit_to)
+        end
+        message
       end
 
     end

data/lib/midi-message/process/processor.rb

@@ -8,19 +8,27 @@ module MIDIMessage
       
       def self.included(base)
         base.extend(ClassMethods)
-        base.send(:attr_reader, :message)
+        #base.send(:attr_reader, :message)
+      end
+      
+      def process(messages = nil)
+        messages = @message unless @message.nil?
+        result = [messages].flatten.map { |message| process_single(message) }
+        result.kind_of?(Array) && result.size == 1 ? result.first : result
       end
 
       module ClassMethods
-        def process(*a, &block)
-          new(*a).process(&block)
+        
+        def process(msg, *a, &block)
+          new(*a).process(msg, &block)
         end
+        
       end
 
       private
 
-      def initialize_processor(message)
-        @message = message
+      def initialize_processor(options)
+        @message = options[:message]
       end
 
     end

data/lib/midi-message/process/transpose.rb

@@ -10,17 +10,17 @@ module MIDIMessage
 
       attr_reader :factor, :property
       
-      def initialize(message, prop, factor, options = {})
+      def initialize(prop, factor, options = {})
         @factor = factor
-        @message = message
         @property = prop
-        initialize_processor(message)
+        
+        initialize_processor(options)
       end
 
-      def process
-        val = @message.send(@property)
-        @message.send("#{@property}=", val + @factor)
-        @message
+      def process_single(message)
+        val = message.send(@property)
+        message.send("#{@property}=", val + @factor)
+        message
       end
 
     end

data/test/test_filter.rb

@@ -11,84 +11,84 @@ class FilterTest < Test::Unit::TestCase
   def test_high_pass_note_reject
     msg = MIDIMessage::NoteOn["C0"].new(0, 100)
     assert_equal(12, msg.note)
-    outp = HighPassFilter.new(msg, :note, 20).process
+    outp = HighPassFilter.new(:note, 20).process(msg)
     assert_equal(nil, outp)
   end
 
   def test_high_pass_note_accept
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = HighPassFilter.new(msg, :note, 20).process
+    outp = HighPassFilter.new(:note, 20).process(msg)
     assert_equal(msg, outp)
   end
 
   def test_low_pass_note_reject
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = LowPassFilter.new(msg, :note, 50).process
+    outp = LowPassFilter.new(:note, 50).process(msg)
     assert_equal(nil, outp)
   end
 
   def test_low_pass_note_accept
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = LowPassFilter.new(msg, :note, 100).process
+    outp = LowPassFilter.new(:note, 100).process(msg)
     assert_equal(msg, outp)
   end
 
   def test_band_pass_note_reject
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = BandPassFilter.new(msg, :note, (20..50)).process
+    outp = BandPassFilter.new(:note, (20..50)).process(msg)
     assert_equal(nil, outp)
   end
 
   def test_band_pass_note_accept
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = BandPassFilter.new(msg, :note, (20..100)).process
+    outp = BandPassFilter.new(:note, (20..100)).process(msg)
     assert_equal(msg, outp)
   end
   
   def test_band_reject_note_reject
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = NotchFilter.new(msg, :note, (20..70)).process
+    outp = NotchFilter.new(:note, (20..70)).process(msg)
     assert_equal(nil, outp)
   end
 
   def test_band_reject_note_accept
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = NotchFilter.new(msg, :note, (20..50)).process
+    outp = NotchFilter.new(:note, (20..50)).process(msg)
     assert_equal(msg, outp)
   end
   
   def test_multiband_note_reject
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = Filter.new(msg, :note, [(20..30), (40..50)]).process
+    outp = Filter.new(:note, [(20..30), (40..50)]).process(msg)
     assert_equal(nil, outp)
   end
 
   def test_multiband_note_accept
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = Filter.new(msg, :note, [(20..30), (50..70)]).process
+    outp = Filter.new(:note, [(20..30), (50..70)]).process(msg)
     assert_equal(msg, outp)
   end
   
   def test_multinotch_note_reject
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = Filter.new(msg, :note, [(20..30), (55..65)], :reject => true).process
+    outp = Filter.new(:note, [(20..30), (55..65)], :reject => true).process(msg)
     assert_equal(nil, outp)
   end
 
   def test_multinotch_note_accept
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    outp = Filter.new(msg, :note, [(20..30), (40..50)], :reject => true).process
+    outp = Filter.new(:note, [(20..30), (40..50)], :reject => true).process(msg)
     assert_equal(msg, outp)
   end
   

data/test/test_limit.rb

@@ -7,32 +7,39 @@ class LimitTest < Test::Unit::TestCase
   include MIDIMessage
   include MIDIMessage::Process
   include TestHelper
+  
+  def test_numeric_range
+    msg = MIDIMessage::NoteOn["C0"].new(0, 100)
+    assert_equal(12, msg.note)
+    Limit.new(:note, 30).process(msg)
+    assert_equal(30, msg.note)    
+  end
 
   def test_low_note
     msg = MIDIMessage::NoteOn["C0"].new(0, 100)
     assert_equal(12, msg.note)
-    Limit.new(msg, :note, (20..50)).process
+    Limit.new(:note, (20..50)).process(msg)
     assert_equal(20, msg.note)
   end
 
   def test_high_note
     msg = MIDIMessage::NoteOn["C6"].new(0, 100)
     assert_equal(84, msg.note)
-    Limit.new(msg, :note, (20..50)).process
+    Limit.new(:note, (20..50)).process(msg)
     assert_equal(50, msg.note)
   end
 
   def test_low_velocity
     msg = MIDIMessage::NoteOn["C0"].new(0, 10)
     assert_equal(10, msg.velocity)
-    Limit.new(msg, :velocity, (30..110)).process
+    Limit.new(:velocity, (30..110)).process(msg)
     assert_equal(30, msg.velocity)
   end
 
   def test_high_velocity
     msg = MIDIMessage::NoteOn["C6"].new(0, 120)
     assert_equal(120, msg.velocity)
-    Limit.new(msg, :velocity, (25..75)).process
+    Limit.new(:velocity, (25..75)).process(msg)
     assert_equal(75, msg.velocity)
   end
   

data/test/test_note_event.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class NoteEventTest < Test::Unit::TestCase
+
+  include MIDIMessage
+  include TestHelper
+  
+  def test_create_event
+    msg = NoteOn.new(0, 0x40, 0x40)
+    event = Event::Note.new(msg, 10)
+    assert_equal(msg, event.start)
+    assert_equal(10, event.duration)
+    assert_equal(NoteOff, event.finish.class)
+    assert_equal(msg.note, event.finish.note)
+    assert_equal(msg.note, event.note) 
+  end
+
+  def test_override_finish
+    msg = NoteOn.new(0, 0x40, 0x40)
+    msg2 = NoteOff.new(0, 0x40, 127)
+    event = Event::Note.new(msg, 5, :finish => msg2)
+    assert_equal(msg, event.start)
+    assert_equal(5, event.duration)
+    assert_equal(0x40, event.start.velocity)
+    assert_equal(NoteOff, event.finish.class)
+    assert_equal(0x40, event.finish.note)
+    assert_equal(127, event.finish.velocity)
+  end
+  
+end

data/test/test_transpose.rb

@@ -11,28 +11,28 @@ class TransposeTest < Test::Unit::TestCase
   def test_transpose_note_up
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    Transpose.new(msg, :note, 5).process
+    Transpose.new(:note, 5).process(msg)
     assert_equal(65, msg.note)
   end
 
   def test_transpose_velocity_up
     msg = MIDIMessage::NoteOn["C4"].new(0, 82)
     assert_equal(82, msg.velocity)
-    Transpose.new(msg, :velocity, 10).process
+    Transpose.new(:velocity, 10).process(msg)
     assert_equal(92, msg.velocity)
   end
 
   def test_transpose_note_down
     msg = MIDIMessage::NoteOn["C4"].new(0, 100)
     assert_equal(60, msg.note)
-    Transpose.new(msg, :note, -5).process
+    Transpose.new(:note, -5).process(msg)
     assert_equal(55, msg.note)
   end
 
   def test_transpose_velocity_down
     msg = MIDIMessage::NoteOn["C4"].new(0, 82)
     assert_equal(82, msg.velocity)
-    Transpose.new(msg, :velocity, -10).process
+    Transpose.new(:velocity, -10).process(msg)
     assert_equal(72, msg.velocity)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: midi-message
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-12 00:00:00.000000000Z
+date: 2011-09-27 00:00:00.000000000Z
 dependencies: []
 description: MIDI messages, objectified in Ruby
 email:
@@ -21,6 +21,7 @@ files:
 - lib/midi-message/channel_message.rb
 - lib/midi-message/constant.rb
 - lib/midi-message/context.rb
+- lib/midi-message/event/note.rb
 - lib/midi-message/note_message.rb
 - lib/midi-message/parser.rb
 - lib/midi-message/process/filter.rb
@@ -39,6 +40,7 @@ files:
 - test/test_filter.rb
 - test/test_limit.rb
 - test/test_mutability.rb
+- test/test_note_event.rb
 - test/test_parser.rb
 - test/test_processor.rb
 - test/test_short_message.rb