midi-message 0.3.2 → 0.4.1

data/README.rdoc

@@ -1,100 +0,0 @@
-= MIDI Message
-
-{pic}[http://img208.imageshack.us/img208/5623/mks80small.jpg]
-
-MIDI messages, objectified in Ruby
-
-== Features
-
-* Flexible API to accommodate various sources and destinations of MIDI data
-* Simple OO approach to System Exclusive data and devices
-* {YAML dictionary of MIDI constants}[https://github.com/arirusso/midi-message/blob/master/lib/midi.yml]
-	
-== Install
-
-  gem install midi-message
-
-== Usage
-
-  require 'midi-message'
-  
-  include MIDIMessage
-  
-==== Basic Messages
-
-There are a few ways to create a new MIDI message.  Here are some examples
-    
-  NoteOn.new(0, 64, 64)
-  
-  NoteOn["E4"].new(0, 100)
-  
-  with(:channel => 0, :velocity => 100) { note_on("E4") }
-
-Those expressions all evaluate to the same object
-
-  #<MIDIMessage::NoteOn:0x9c1c240
-   @channel=0,
-   @data=[64, 64],
-   @name="E4",
-   @note=64,
-   @status=[9, 0],
-   @velocity=64,
-   @verbose_name="Note On: E4">
-
-==== SysEx Messages
-
-As with any kind of message, you can begin with raw data
-  
-  SystemExclusive.new(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-  
-Or in a more object oriented way
-  
-  synth = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    
-  SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x00, :node => synth)
-  
-A Node represents a device that you're sending a message to (eg. your Yamaha DX7 is a Node).  Sysex messages can either be a Command or Request
-  
-You can use the Node to instantiate a message
-  
-  synth.command([0x40, 0x7F, 0x00], 0x00)
-  
-One way or another, you will wind up with a pair of objects like this
-
-   #<MIDIMessage::SystemExclusive::Command:0x9c1e57c
-   @address=[64, 0, 127],
-   @checksum=[65],
-   @data=[0],
-   @node=
-    #<MIDIMessage::SystemExclusive::Node:0x9c1e5a4
-     @device_id=16,
-     @manufacturer_id=65,
-     @model_id=66>>
-     
-==== Parsing
-
-The parse method will take any valid message data and return the object representation
-
-  MIDIMessage.parse(0x90, 0x40, 0x40)
-  
-    #<MIDIMessage::NoteOn:0x9c1c240 ..>
-  
-  MIDIMessage.parse(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-  
-    #<MIDIMessage::SystemExclusive::Command:0x9c1e57c ..>
-  
-Check out {nibbler}[http://github.com/arirusso/nibbler] for more advanced parsing
-
-== API Documentation
-
-* {rdoc}[http://rubydoc.info/github/arirusso/midi-message]
-
-== Author
-
-* {Ari Russo}[http://github.com/arirusso] <ari.russo at gmail.com>
-
-== License
-
-Apache 2.0, See the file LICENSE
-
-Copyright (c) 2011 Ari Russo

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

@@ -1,31 +0,0 @@
-#!/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

@@ -1,63 +0,0 @@
-#!/usr/bin/env ruby
-
-module MIDIMessage
-
-  module Process
-
-    # Use the Filter superclass when you need a multi-band filter
-    class Filter
-
-      include Processor
-
-      attr_reader :bandwidth, :property, :reject
-      
-      def initialize(prop, bandwidth, options = {})
-        @bandwidth = [bandwidth].flatten
-        @property = prop
-        @reject = options[:reject] || false
-
-        initialize_processor(options)
-      end
-
-      def process_single(message)
-        val = message.send(@property)
-        result = @bandwidth.map do |bw| 
-          case bw
-            when Range then val >= bw.min && val <= bw.max ? message : nil
-            when Numeric then val == bw ? message : nil
-          end
-        end
-        result.include?(message) ^ @reject ? message : nil
-      end
-
-    end
-
-    class LowPassFilter < Filter
-      def initialize(prop, max, options = {})
-        super(prop, (0..max), options)
-      end
-    end
-
-    class HighPassFilter < Filter
-      def initialize(prop, min, options = {})
-        super(prop, (min..127), options)
-      end
-    end
-
-    class BandPassFilter < Filter
-      def initialize(prop, accept_range, options = {})
-        options[:reject] = false
-        super(prop, accept_range, options)
-      end
-    end
-
-    class BandRejectFilter < Filter
-      def initialize(prop, reject_range, options = {})
-        options[:reject] = true
-        super(prop, reject_range, options)
-      end
-    end
-    NotchFilter = BandRejectFilter
-
-  end
-end

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

@@ -1,36 +0,0 @@
-#!/usr/bin/env ruby
-
-module MIDIMessage
-
-  module Process
-    
-    class Limit
-
-      include Processor
-
-      attr_reader :property, :limit_to
-      alias_method :range, :limit_to
-      
-      def initialize(prop, limit_to, options = {})
-        @limit_to = limit_to
-        @property = prop
-        
-        initialize_processor(options)
-      end
-
-      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
-
-  end
-  
-end

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

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-
-module MIDIMessage
-
-  module Process
-
-    module Processor
-      
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.send(:attr_reader, :name)
-      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(msg, *a, &block)
-          new(*a).process(msg, &block)
-        end
-        
-      end
-
-      private
-
-      def initialize_processor(options)
-        @message = options[:message]
-        @name = options[:name]
-      end
-
-    end
-
-  end
-  
-end

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

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby
-
-module MIDIMessage
-
-  module Process
-    
-    class Transpose
-
-      include Processor
-
-      attr_reader :factor, :property
-      
-      def initialize(prop, factor, options = {})
-        @factor = factor
-        @property = prop
-        
-        initialize_processor(options)
-      end
-
-      def process_single(message)
-        val = message.send(@property)
-        message.send("#{@property}=", val + @factor)
-        message
-      end
-
-    end
-
-  end
-  
-end

data/test/test_filter.rb

@@ -1,115 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'helper'
-
-class FilterTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include MIDIMessage::Process
-  include TestHelper
-
-  def test_high_pass_note_reject
-    msg = MIDIMessage::NoteOn["C0"].new(0, 100)
-    assert_equal(12, msg.note)
-    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(: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(: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(: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(: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(: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(: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(: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(: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(: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(: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(:note, [(20..30), (40..50)], :reject => true).process(msg)
-    assert_equal(msg, outp)
-  end
-  
-  def test_numeric_note_accept
-    msg1 = MIDIMessage::NoteOn["C4"].new(0, 100)
-    msg2 = MIDIMessage::NoteOn["C5"].new(0, 100)
-    f = Filter.new(:note, 60)
-    outp = f.process(msg1)
-    assert_equal(msg1, outp)
-    outp = f.process(msg2)
-    assert_equal(nil, outp)
-  end
-  
-  def test_numeric_note_reject
-    msg1 = MIDIMessage::NoteOn["C4"].new(0, 100)
-    msg2 = MIDIMessage::NoteOn["C5"].new(0, 100)
-    f = Filter.new(:note, 60, :reject => true)
-    outp = f.process(msg1)
-    assert_equal(nil, outp)
-    outp = f.process(msg2)
-    assert_equal(msg2, outp)
-  end
-  
-end

data/test/test_limit.rb

@@ -1,46 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'helper'
-
-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(: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(: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(: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(:velocity, (25..75)).process(msg)
-    assert_equal(75, msg.velocity)
-  end
-  
-end

data/test/test_note_event.rb

@@ -1,32 +0,0 @@
-#!/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_processor.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'helper'
-
-class ProcessorTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include MIDIMessage::Process
-  include TestHelper
-
-  def test_class_method
-    msg = MIDIMessage::NoteOn["C4"].new(0, 100)
-    assert_equal(60, msg.note)
-    Transpose.process(msg, :note, 5)
-    assert_equal(65, msg.note)
-  end
-
-
-end

data/test/test_transpose.rb

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'helper'
-
-class TransposeTest < Test::Unit::TestCase
-
-  include MIDIMessage
-  include MIDIMessage::Process
-  include TestHelper
-
-  def test_transpose_note_up
-    msg = MIDIMessage::NoteOn["C4"].new(0, 100)
-    assert_equal(60, msg.note)
-    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(: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(: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(:velocity, -10).process(msg)
-    assert_equal(72, msg.velocity)
-  end
-
-end