midi-instrument 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4dc9ef33817d2595aa97bec2239f28f1b1779bb4
+  data.tar.gz: 05d6227e8b18d1a7a36b439661ea0d7204ec2770
+SHA512:
+  metadata.gz: b377e4696a2ab9f80d0c76a10287891883a1ab04162d78b0b0d5c88ba6981f384577ee0b82a1a8fab8da1c8780797699b9cb3f3e3896eb57369354da1cade4cf
+  data.tar.gz: c3c7bf02d6ab64895a10b0319bd7ecf387d40885b0c0c184fd79922149eda6edc776d26715f573d83afa6006448b87d86ec7e24453715d44155d1c5eea6c38be

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2011-2014 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,23 @@
+#MIDI Instrument
+
+Core MIDI instrument functionality
+
+Used by [Diamond](http://github.com/arirusso/diamond)
+
+## Installation
+
+`gem install midi-instrument`
+  
+  or with Bundler, add this to your Gemfile
+  
+`gem "midi-instrument"` 
+
+## Documentation
+
+* [rdoc](http://rubydoc.info/github/arirusso/midi-instrument) 
+
+## License
+
+Licensed under Apache 2.0, See the file LICENSE
+
+Copyright © 2011-2014 Ari Russo

data/lib/midi-instrument.rb

@@ -0,0 +1,32 @@
+#
+# MIDI Instrument
+# Core MIDI Instrument Functionality
+#
+# (c)2011-2014 Ari Russo
+# Licensed under Apache 2.0
+# 
+
+# libs
+require "forwardable"
+require "midi-eye"
+require "midi-fx"
+require "midi-message"
+require "unimidi"
+
+# modules
+require "midi-instrument/api"
+require "midi-instrument/device"
+require "midi-instrument/message"
+
+# classes
+require "midi-instrument/input"
+require "midi-instrument/listener"
+require "midi-instrument/node"
+require "midi-instrument/note_event"
+require "midi-instrument/output"
+
+module MIDIInstrument
+  
+  VERSION = "0.4.1"
+  
+end

data/lib/midi-instrument/api.rb

@@ -0,0 +1,14 @@
+module MIDIInstrument
+
+  module API
+
+    def self.included(base)
+      base.send(:extend, Forwardable)
+      base.send(:def_delegators, :@input, :omni_on)
+      base.send(:def_delegators, :@output, :mute, :toggle_mute, :mute=, :muted?, :mute?)
+    end
+
+  end
+
+end
+

data/lib/midi-instrument/device.rb

@@ -0,0 +1,38 @@
+module MIDIInstrument
+
+  # Manage MIDI Devices
+  module Device
+
+    extend self
+
+    # Partition UniMIDI devices into a hash of inputs and outputs
+    # @param [Array<UniMIDI::Input, UniMIDI::Output>, UniMIDI::Input, UniMIDI::Output] devices Input or output device(s).
+    # @return [Hash] Partitioned arrays of inputs and outputs.
+    def partition(devices)
+      devices = [(devices || [])].flatten
+      outputs = devices.select { |device| output?(device) }
+      inputs = devices.select { |device| input?(device) }
+      {
+        :input => inputs,
+        :output => outputs
+      }
+    end
+
+    private
+
+    # Is this device an output?
+    # @param [UniMIDI::Output, Object] device
+    # @return [Boolean]
+    def output?(device)
+      device.respond_to?(:puts)
+    end
+
+    # Is this device an input?
+    # @param [UniMIDI::Input, Object] device
+    # @return [Boolean]
+    def input?(device)
+      device.respond_to?(:type) && device.type == :input && device.respond_to?(:gets)
+    end
+    
+  end
+end

data/lib/midi-instrument/input.rb

@@ -0,0 +1,151 @@
+module MIDIInstrument
+  
+  # Enable a node to listen for MIDI messages on a MIDI input
+  class Input
+
+    extend Forwardable
+
+    attr_reader :devices, :channel
+    def_delegators :@listener, :join
+
+    # @param [Hash] options
+    # @option options [Array<UniMIDI::Input>, UniMIDI::Input] :sources
+    # @option options [Hash] :input_map
+    def initialize(options = {})
+      @listener = Listener.new(options[:sources])
+      @devices = InputContainer.new(@listener)
+      @channel = nil
+      @channel_filter = nil
+    end
+
+    # Add a MIDI input callback
+    # @param [Hash] match Matching spec
+    # @param [Proc] callback
+    # @return [Listen]
+    def receive(match = {}, &block)
+      if block_given?
+        @listener.receive(match) do |event|
+          event = filter_event(event)
+          yield(event)
+        end
+      end
+      self
+    end
+
+    def add(*messages)
+      messages = Message.to_messages([messages].flatten)
+      messages = messages.map { |message| filter_message(message) }.compact
+      @listener.add(*messages) unless messages.empty?
+      messages
+    end
+    alias_method :<<, :add
+    
+    # Set the listener to acknowledge notes on all channels
+    # @return [Boolean]
+    def omni
+      @channel_filter = nil
+      @channel = nil
+      true
+    end
+    alias_method :omni_on, :omni
+
+    # Set the listener to only acknowledge notes from a specific channel
+    # @return [Boolean]
+    def channel=(channel)
+      @channel_filter = channel.nil? ? nil : MIDIFX::Filter.new(:channel, channel, :name => :input_channel)
+      @channel = channel
+      true
+    end
+
+    # Replace the devices with the given devices
+    # @param [Array<UniMIDI::Inputs>] devices
+    # @return [InputContainer]
+    def devices=(devices)
+      @devices.clear
+      @devices += devices
+      @devices
+    end
+
+    private
+
+    def filter_event(event)
+      if !@channel_filter.nil?
+        if !(message = filter_message(event[:message])).nil?
+          event[:message] = message
+          event
+        end
+      else
+        event
+      end
+    end
+
+    def filter_message(message)
+      message = @channel_filter.process(message) unless @channel_filter.nil?
+      message
+    end
+
+    # Container class that handles updating the listener when changes are made
+    class InputContainer < Array
+
+      # @param [Listener] listener
+      def initialize(listener)
+        @listener = listener
+      end
+
+      # Add an input
+      # @param [UniMIDI::Input] input
+      # @return [InputContainer] 
+      def <<(input)
+        result = super
+        @listener.add_input(input)
+        result
+      end
+
+      # Add multiple devices
+      # @param [Array<UniMIDI::Input>] devices
+      # @return [InputContainer]
+      def +(devices)
+        result = super
+        @listener.add_input(devices)
+        result
+      end
+
+      # Add multiple devices
+      # @param [Array<UniMIDI::Input>] devices
+      # @return [InputContainer]
+      def concat(devices)
+        result = super
+        @listener.add_input(devices)
+        result
+      end
+
+      # Delete an input
+      # @param [UniMIDI::Input]
+      # @return [UniMIDI::Input]
+      def delete(input)
+        result = super
+        @listener.remove_input(input)
+        result
+      end
+
+      # Clear all devices
+      # @return [InputContainer]
+      def clear
+        @listener.inputs.each { |input| delete(input) }
+        super
+      end
+
+      # Delete multiple devices
+      # @param [Proc] block
+      # @return [InputContainer]
+      def delete_if(&block)
+        devices = super
+        @listener.remove_input(devices)
+        self
+      end
+
+    end
+
+  end
+  
+end

data/lib/midi-instrument/listener.rb

@@ -0,0 +1,61 @@
+module MIDIInstrument
+
+  # A light wrapper for MIDIEye::Listener
+  class Listener
+    
+    extend Forwardable
+        
+    def_delegators :@listener, :add_input, :remove_input, :stop
+    def_delegator :@listener, :remove_listener, :delete_event
+    
+    # @param [Array<UniMIDI::Input>, UniMIDI::Input] sources
+    def initialize(sources)
+      @listener = MIDIEye::Listener.new([sources].flatten)
+    end
+
+    # Manually add messages to the MIDI input buffer
+    # @param [Array<MIDIMessage>, MIDIMessage, *MIDIMessage] args
+    # @return [Array<MIDIMessage>]
+    def add(*messages)
+      [messages].flatten.map do |message|
+        report = { 
+          :message => message, 
+          :timestamp => Time.now.to_f 
+        }
+        @listener.event.enqueue_all(report)
+        report
+      end
+    end
+    alias_method :<<, :add
+
+    # Join the listener thread
+    def join
+      start if !@listener.running?
+      @listener.join
+    end
+
+    # The active inputs
+    # @return [Array<UniMIDI::Input>]
+    def inputs
+      @listener.sources
+    end
+
+    # Start the listener
+    def start
+      @listener.start(:background => true)
+    end
+    
+    # Bind a message callback
+    # @param [Hash] match
+    # @param [Proc] callback
+    # @return [Boolean]
+    def receive(match = {}, &callback)
+      @listener.listen_for(match, &callback)
+      start if !@listener.running?
+      true
+    end
+              
+  end
+  
+end
+

data/lib/midi-instrument/message.rb

@@ -0,0 +1,87 @@
+module MIDIInstrument
+
+  # Helper for converting MIDI messages
+  module Message
+
+    extend self
+
+    # Convert the input to MIDI messages
+    # @param [Array<MIDIMessage>, Array<String>, MIDIMessage, *MIDIMessage, String] args
+    # @return [Array<MIDIMessage>]
+    def to_messages(*args)
+      data = [args.dup].flatten
+      if data.all? { |item| note?(item) }
+        Message.to_note_ons(*data) # string note names
+      elsif data.all? { |item| message?(item) }
+        data # messages
+      end
+    end
+
+    # Convert the input to bytes
+    # @param [Array<Fixnum>, Array<MIDIMessage>, Array<String>, MIDIMessage, *MIDIMessage, String] args
+    # @return [Array<Fixnum>]
+    def to_bytes(*args)
+      messages = to_messages(*args)
+      if !messages.nil?
+        messages.map(&:to_bytes).flatten
+      elsif args.all? { |arg| bytes?(arg)}
+        args
+      end
+    end
+
+    # Convert the input to MIDI note on messages
+    # @param [*MIDIMessage::NoteOn, *String] args
+    # @param [Hash] options
+    # @option options [Fixnum] :default_channel
+    # @option options [Fixnum] :default_velocity
+    # @return [Array<MIDIMessage::NoteOn, nil>]
+    def to_note_ons(*args)
+      notes = [args.dup].flatten
+      options = notes.last.kind_of?(Hash) ? notes.pop : {}
+      notes.map do |note|
+        case note
+        when String then string_to_note_on(note, options) if note?(note)
+        when MIDIMessage::NoteOn then note
+        end
+      end
+    end
+
+    # Does this object look like a MIDI byte?
+    # @param [Object] object
+    # @return [Boolean]
+    def bytes?(object)
+      object.kind_of?(Fixnum) && object >= 0x00 && object <= 0xFF
+    end
+
+    private
+
+    # Is this object a MIDI message?
+    # @param [Object] object
+    # @return [Boolean]
+    def message?(object)
+      object.class.name.match(/\AMIDIMessage::[a-zA-Z]+\z/)
+    end
+
+    # Is this object a string note name? eg "A4"
+    # @param [Object] object
+    # @return [Boolean]
+    def note?(object)
+      object.kind_of?(String) && object.match(/\A[a-zA-Z]{1}(\#|b)?\-?\d{1}\z/)
+    end
+
+    # Convert the given string (eg "A4") to a note on message object
+    # @param [String] string
+    # @param [Hash] options
+    # @option options [Fixnum] :default_channel
+    # @option options [Fixnum] :default_velocity
+    # @return [MIDIMessage::NoteOn]
+    def string_to_note_on(string, options = {})
+      channel = options.fetch(:default_channel, 0)
+      velocity = options.fetch(:default_velocity, 100)
+      MIDIMessage::NoteOn[string].new(channel, velocity)
+    end
+
+  end
+
+end
+

data/lib/midi-instrument/node.rb

@@ -0,0 +1,48 @@
+module MIDIInstrument
+
+  # Can listen for and send MIDI messages
+  class Node
+
+    include API
+
+    attr_reader :input, :output
+
+    # @param [Hash] options
+    # @option options [Array<UniMIDI::Input>, UniMIDI::Input] :sources Inputs to listen for MIDI on
+    def initialize(options = {})
+      @input = Input.new(options)
+      @output = Output.new
+    end
+
+    def inputs
+      @input.devices
+    end
+
+    def outputs
+      @output.devices
+    end
+
+    def receive_channel
+      @input.channel
+    end
+    alias_method :rx_channel, :receive_channel
+
+    def receive_channel=(channel)
+      @input.channel = channel
+    end
+    alias_method :rx_channel=, :receive_channel=
+
+    def transmit_channel
+      @output.channel
+    end
+    alias_method :tx_channel, :transmit_channel
+
+    def transmit_channel=(channel)
+      @output.channel = channel
+    end
+    alias_method :tx_channel=, :transmit_channel=
+
+  end
+
+end
+

data/lib/midi-instrument/note_event.rb

@@ -0,0 +1,29 @@
+module MIDIInstrument
+
+  # An NoteEvent is a pairing of a MIDI NoteOn and NoteOff message.  Its duration can correspond to sequencer ticks
+  class NoteEvent
+
+    extend Forwardable
+
+    attr_reader :start,
+      :finish,
+      :length
+
+    alias_method :duration, :length
+
+    def_delegators :start, :note
+
+    # @param [MIDIMessage::NoteOn] start_message
+    # @param [Fixnum] duration
+    # @param [Hash] options
+    # @option options [MIDIMessage::NoteOff] :finish
+    def initialize(start_message, duration, options = {})
+      @start = start_message
+      @length = duration
+
+      @finish = options[:finish] || start_message.to_note_off
+    end
+
+  end
+
+end

data/lib/midi-instrument/output.rb

@@ -0,0 +1,103 @@
+module MIDIInstrument
+
+  # Send MIDI messages
+  class Output
+
+    attr_reader :devices, :channel
+    attr_writer :mute
+
+    def initialize
+      @channel = nil
+      @channel_filter = nil
+      @mute = false
+      @devices = []
+    end
+
+    # Set the output to convert all emitted notes to a specific channel
+    # @param [Fixnum, nil] channel
+    # @return [Boolean]
+    def channel=(channel)
+      @channel_filter = if channel.nil?
+        nil
+      else
+        MIDIFX::Limit.new(:channel, channel, :name => :output_channel)
+      end
+      @channel = channel
+      true
+    end
+
+    # Emit messages
+    # @param [*Fixnum, *MIDIMessage::NoteOn, *MIDIMessage::NoteOff, *String] args
+    # @return [Array<Fixnum>]
+    def puts(*args)
+      bytes = to_bytes(args)
+      if !@mute
+        @devices.each { |output| output.puts(*bytes) }
+      end
+      bytes  
+    end
+    alias_method :<<, :puts
+
+    # Toggle muted output
+    # @return [Boolean]
+    def toggle_mute
+      @mute = !@mute
+    end
+
+    # Mute the output
+    # @return [TrueClass]
+    def mute
+      @mute = true
+    end
+
+    # Un-mute the output
+    # @return [FalseClass]
+    def unmute
+      @mute = false
+    end
+
+    # Is the output muted?
+    # @return [Boolean]
+    def mute?
+      @mute
+    end
+
+    # Replace the devices with the given devices
+    # @param [Array<UniMIDI::Outputs>] devices
+    # @return [OutputContainer]
+    def devices=(devices)
+      @devices.clear
+      @devices += devices
+      @devices
+    end
+
+    private
+
+    # Convert the input to MIDI message bytes
+    # @param [Array<Fixnum>, Array<MIDIMessage>] args
+    # @return [Array<Fixnum>]
+    def to_bytes(args)
+      data = [args.dup].flatten
+      messages = Message.to_messages(*data)
+      if !messages.nil?
+        messages = filter_output(messages)
+        messages.map(&:to_bytes).flatten
+      elsif Message.bytes?(data)
+        data
+      end
+    end
+
+    # Filter messages for output
+    # @param [Array<MIDIMessage::ChannelMessage>] messages
+    # @return [Array<MIDIMessage::ChannelMessage>] 
+    def filter_output(messages)
+      if @channel_filter.nil?
+        messages
+      else
+        messages.map { |message| @channel_filter.process(message) }
+      end
+    end
+
+  end
+
+end

data/test/device_test.rb

@@ -0,0 +1,26 @@
+require "helper"
+
+class MIDIInstrument::DeviceTest < Test::Unit::TestCase
+
+  context "Device" do
+
+    context ".partition" do
+
+      should "partition some devices" do
+        inputs = UniMIDI::Input.all
+        outputs = UniMIDI::Output.all
+        devices = inputs + outputs
+        result = MIDIInstrument::Device.partition(devices)
+        assert_not_nil result
+        assert result.kind_of?(Hash)
+        assert_not_nil result[:input]
+        assert_not_nil result[:output]
+        assert_equal inputs, result[:input]
+        assert_equal outputs, result[:output]
+      end
+
+     end
+  end
+
+end
+

data/test/helper.rb

@@ -0,0 +1,18 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + "/../lib"
+
+require "test/unit"
+require "mocha/test_unit"
+require "shoulda-context"
+require "midi-instrument"
+
+module TestHelper
+  
+  def self.select_devices
+    $test_device ||= {}
+    { :input => UniMIDI::Input, :output => UniMIDI::Output }.each do |type, klass|
+      $test_device[type] = klass.gets
+    end
+  end
+         
+end

data/test/input_test.rb

@@ -0,0 +1,92 @@
+require "helper"
+
+class MIDIInstrument::InputTest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  context "Input" do
+
+    setup do
+      @input = MIDIInstrument::Input.new
+    end
+
+    context "#receive" do
+
+      should "add callback" do
+        match = { :class => MIDIMessage::NoteOn }
+        block = proc { puts "hello" }
+        MIDIInstrument::Listener.any_instance.expects(:receive).once.with(match).yields(block)
+        result = @input.receive(match, &block)
+        assert_equal @input, result
+      end
+      
+    end
+
+    context "#add" do
+
+      should "accept strings" do
+        MIDIInstrument::Listener.any_instance.expects(:add).once.with(is_a(MIDIMessage::NoteOn), is_a(MIDIMessage::NoteOn), is_a(MIDIMessage::NoteOn))
+        @input.add("A3", "B4", "C5")
+      end
+
+      should "accept MIDI messages" do
+        MIDIInstrument::Listener.any_instance.expects(:add).once.with(is_a(MIDIMessage::NoteOn), is_a(MIDIMessage::NoteOn), is_a(MIDIMessage::NoteOn))
+        @input.add(MIDIMessage::NoteOn["C3"].new(3, 100), MIDIMessage::NoteOn["B4"].new(5, 100), MIDIMessage::NoteOn["D7"].new(7, 100))
+      end
+
+      should "not suppress unknown objects" do
+        MIDIInstrument::Listener.any_instance.expects(:add).never
+        assert_raise(NoMethodError) { @input.add("hello", "how", "are", "you") }
+      end
+
+    end
+
+    context "#omni" do
+      
+      should "not have a receive channel" do
+        assert_nil @input.instance_variable_get("@channel_filter")
+        @input.channel = 4
+        assert_equal 4, @input.channel
+        @input.omni
+        assert_nil @input.channel
+        assert_nil @input.instance_variable_get("@channel_filter")
+      end
+
+    end
+
+    context "#channel=" do
+
+      should "have filter when channel is specified" do
+        assert_nil @input.instance_variable_get("@channel_filter")
+        @input.channel = 3
+        assert_not_nil @input.instance_variable_get("@channel_filter")
+        assert_equal 3, @input.channel
+      end
+
+      should "not have filter when channel is nil" do
+        @input.channel = 3
+        assert_not_nil @input.instance_variable_get("@channel_filter")
+        assert_equal 3, @input.channel
+        @input.channel = nil
+        assert_nil @input.instance_variable_get("@channel_filter")
+        assert_nil @input.channel
+      end
+
+    end
+
+    context "#devices=" do
+
+      should "replace devices" do
+        assert_empty @input.devices
+        inputs = UniMIDI::Input.all
+        @input.devices = inputs
+        assert_equal inputs, @input.devices
+      end
+
+    end
+
+  end
+
+end
+
+

data/test/listener_test.rb

@@ -0,0 +1,31 @@
+require "helper"
+
+class MIDIInstrument::ListenerTest < Test::Unit::TestCase
+
+  context "Listener" do
+
+    setup do
+      MIDIInstrument::Listener.any_instance.unstub(:add)
+      @listener = MIDIInstrument::Listener.new(Object.new)
+    end
+
+    context "#add" do
+
+      should "output hashes with timestamps" do
+        notes = [
+          MIDIMessage::NoteOn["C3"].new(3, 100), 
+          MIDIMessage::NoteOn["B4"].new(5, 100), 
+          MIDIMessage::NoteOn["D7"].new(7, 100)
+        ]
+        result = @listener.add(*notes)
+        assert_not_nil result
+        assert_not_empty result
+        assert result.all? { |r| r.kind_of?(Hash) }
+        refute result.any? { |r| r[:timestamp].nil? }
+      end
+
+    end
+
+  end
+
+end

data/test/message_test.rb

@@ -0,0 +1,106 @@
+require "helper"
+
+class MIDIInstrument::MessageTest < Test::Unit::TestCase
+
+  context "Message" do
+
+    context ".to_messages" do
+
+      should "convert strings to note on messages" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        result = MIDIInstrument::Message.to_messages(*names)
+        assert_not_nil result
+        assert_not_empty result
+        assert_equal names.size, result.size
+        assert result.all? { |item| item.is_a?(MIDIMessage::NoteOn) }
+        names.each_with_index { |name, i| assert_equal name, result[i].name }
+      end
+
+      should "pass MIDI messages" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        messages  = MIDIInstrument::Message.to_messages(*names)
+        result = MIDIInstrument::Message.to_messages(*messages)
+        assert_not_nil result
+        assert_not_empty result
+        messages.each_with_index { |message,i| assert_equal message.note, result[i].note }
+      end
+
+      should "return nil for unknowns" do
+        assert_nil MIDIInstrument::Message.to_messages("bla", "blah")
+      end
+
+    end
+
+    context ".to_bytes" do
+
+      should "convert messages to bytes" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        messages  = MIDIInstrument::Message.to_messages(*names)
+        result = MIDIInstrument::Message.to_bytes(*messages)
+        assert_not_nil result
+        assert_not_empty result
+        assert result.all? { |item| item.is_a?(Fixnum) }
+        assert_equal messages.map(&:to_a).flatten, result
+      end
+
+      should "convert strings to bytes" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        messages  = MIDIInstrument::Message.to_messages(*names)
+        result = MIDIInstrument::Message.to_bytes(*names)
+        assert_not_nil result
+        assert_not_empty result
+        assert result.all? { |item| item.is_a?(Fixnum) }
+        assert_equal messages.map(&:to_a).flatten, result
+      end
+
+      should "pass bytes" do
+        bytes = [144, 9, 100, 144, 61, 100, 144, 78, 100, 144, 86, 100]
+        result = MIDIInstrument::Message.to_bytes(*bytes)
+        assert_not_nil result
+        assert_not_empty result
+        assert result.all? { |item| item.is_a?(Fixnum) }
+        assert_equal bytes, result
+      end
+
+      should "return nil for unknown" do
+        assert_nil MIDIInstrument::Message.to_bytes("this", "is", "something", "weird", 4560)
+      end
+
+    end
+
+    context ".to_note_ons" do
+
+      should "convert strings to note ons" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        result = MIDIInstrument::Message.to_note_ons(*names)
+        assert_not_nil result
+        assert_not_empty result
+        assert_equal names.size, result.size
+        assert result.all? { |item| item.is_a?(MIDIMessage::NoteOn) }
+        names.each_with_index { |name, i| assert_equal name, result[i].name }
+      end
+
+      should "pass note on messages" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        messages  = MIDIInstrument::Message.to_messages(*names)
+        result = MIDIInstrument::Message.to_note_ons(*messages)
+        assert_not_nil result
+        assert_not_empty result
+        messages.each_with_index { |message,i| assert_equal message.note, result[i].note }
+      end
+
+      should "return nil for unknowns" do
+        result = MIDIInstrument::Message.to_note_ons("blah", "blah", 56904)
+        assert_not_nil result
+        assert_equal 3, result.size
+        assert_empty result.compact
+      end
+
+    end
+    
+  end
+
+end
+
+
+

data/test/note_event_test.rb

@@ -0,0 +1,33 @@
+require "helper"
+
+class MIDIInstrument::NoteEventTest < Test::Unit::TestCase
+
+  context "NoteEvent" do
+
+    context ".new" do
+
+      should "create a note event" do
+        msg = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
+        event = MIDIInstrument::NoteEvent.new(msg, 10)
+        assert_equal(msg, event.start)
+        assert_equal(10, event.duration)
+        assert_equal(MIDIMessage::NoteOff, event.finish.class)
+        assert_equal(msg.note, event.finish.note)
+        assert_equal(msg.note, event.note) 
+      end
+
+      should "override finish" do
+        msg = MIDIMessage::NoteOn.new(0, 0x40, 0x40)
+        msg2 = MIDIMessage::NoteOff.new(0, 0x40, 127)
+        event = MIDIInstrument::NoteEvent.new(msg, 5, :finish => msg2)
+        assert_equal(msg, event.start)
+        assert_equal(5, event.duration)
+        assert_equal(0x40, event.start.velocity)
+        assert_equal(MIDIMessage::NoteOff, event.finish.class)
+        assert_equal(0x40, event.finish.note)
+        assert_equal(127, event.finish.velocity)
+      end
+    end
+  end
+
+end

data/test/output_test.rb

@@ -0,0 +1,100 @@
+require "helper"
+
+class MIDIInstrument::OutputTest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  context "Output" do
+
+    setup do
+      @output = MIDIInstrument::Output.new
+    end
+
+    context "#puts" do
+
+      setup do
+        @output.devices << Object.new
+      end
+
+      should "output string notes" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        @output.devices.first.expects(:puts).times(1)
+        result = @output.puts(*names)
+      end
+
+      should "output MIDI messages" do
+        @output.devices.first.expects(:puts).times(1)
+        result = @output.puts(MIDIMessage::NoteOn["C3"].new(0, 100), MIDIMessage::NoteOn["D3"].new(0, 110))
+      end
+
+      should "output to multiple devices" do
+        4.times do 
+          @output.devices << Object.new
+        end
+        names = ["A-1", "C#4", "F#5", "D6"]
+        @output.devices.each { |device| device.expects(:puts).once }
+        result = @output.puts(*names)
+      end
+      
+    end
+
+    context "#mute" do
+
+      setup do
+        @output.devices << Object.new
+      end
+
+      should "output when not muted" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        refute @output.mute?
+        @output.devices.first.expects(:puts).times(1)
+        result = @output.puts(*names)
+      end
+
+      should "not output when muted" do
+        names = ["A-1", "C#4", "F#5", "D6"]
+        @output.mute
+        assert @output.mute?
+        @output.devices.first.expects(:puts).never
+        result = @output.puts(*names)
+      end
+
+    end
+
+    context "#channel=" do
+
+      should "have filter when channel is specified" do
+        assert_nil @output.instance_variable_get("@channel_filter")
+        @output.channel = 3
+        assert_not_nil @output.instance_variable_get("@channel_filter")
+        assert_equal 3, @output.channel
+      end
+
+      should "not have filter when channel is nil" do
+        @output.channel = 3
+        assert_not_nil @output.instance_variable_get("@channel_filter")
+        assert_equal 3, @output.channel
+        @output.channel = nil
+        assert_nil @output.instance_variable_get("@channel_filter")
+        assert_nil @output.channel
+      end
+
+    end
+
+    context "#devices=" do
+
+      should "replace devices" do
+        assert_empty @output.devices
+        outputs = UniMIDI::Output.all
+        @output.devices = outputs
+        assert_equal outputs, @output.devices
+      end
+
+    end
+
+  end
+
+end
+
+
+

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: midi-instrument
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: midi-eye
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: midi-fx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: midi-message
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: unimidi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5
+description: Core MIDI instrument functionality in Ruby
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/midi-instrument.rb
+- lib/midi-instrument/api.rb
+- lib/midi-instrument/device.rb
+- lib/midi-instrument/input.rb
+- lib/midi-instrument/listener.rb
+- lib/midi-instrument/message.rb
+- lib/midi-instrument/node.rb
+- lib/midi-instrument/note_event.rb
+- lib/midi-instrument/output.rb
+- test/device_test.rb
+- test/helper.rb
+- test/input_test.rb
+- test/listener_test.rb
+- test/message_test.rb
+- test/note_event_test.rb
+- test/output_test.rb
+homepage: http://github.com/arirusso/midi-instrument
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: midi-instrument
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Core MIDI instrument functionality
+test_files: []