midi-jruby 0.0.12 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3556d36dc4530a743c39ee52843ac49c6106d7d1
+  data.tar.gz: 1f9d70df4153c5a152e34260da63f408cabb71d2
+SHA512:
+  metadata.gz: c3adf3f2a801d5c7a56db5f64260d1868ca59ce10da867b4d27f970dbc3cfb891dae40905728afdcb16547491b4d5365f4e25e5dc19e5212cefbedc91b572122
+  data.tar.gz: ab5f514ffd17459df997e5be3a84b58696193c8803b4e89d28a99ef519179e15c0b1442b5b8cd57aa99c0bdc3d2e62920d62397fe67a920495fe36cd1ae1cbed

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2010-2011 Ari Russo
+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.
@@ -10,4 +10,4 @@ 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.
+limitations under the License.

data/README.md

@@ -0,0 +1,45 @@
+# midi-jruby
+
+Realtime MIDI IO with JRuby using the javax.sound.midi API.
+
+In the interest of allowing people on other platforms to utilize your code, you should consider using [unimidi](http://github.com/arirusso/unimidi).  Unimidi is a platform independent wrapper that implements midi-jruby and has a similar API.  
+
+## Features
+
+* Simplified API
+* Input and output on multiple devices concurrently
+* Generalized handling of different MIDI Message types (including SysEx)
+* Timestamped input events
+
+## Install
+
+If you're using Bundler, add this line to your application's Gemfile:
+
+`gem "midi-jruby"`
+
+Otherwise
+
+`gem install midi-jruby`
+	
+## Examples
+
+* [Input](http://github.com/arirusso/midi-jruby/blob/master/examples/input.rb)
+* [Output](http://github.com/arirusso/midi-jruby/blob/master/examples/output.rb)
+
+## Issues
+
+There is [an issue](http://stackoverflow.com/questions/8148898/java-midi-in-mac-osx-broken) that causes javax.sound.midi not to be able to send SysEx messages in some versions.
+
+## Documentation
+
+* [rdoc](http://rdoc.info/gems/midi-jruby)
+
+## Author 
+
+[Ari Russo](http://github.com/arirusso) <ari.russo at gmail.com>
+		
+## License
+
+Apache 2.0, See the file LICENSE
+
+Copyright (c) 2011-2014 Ari Russo

data/lib/midi-jruby/api.rb

@@ -0,0 +1,172 @@
+module MIDIJRuby
+    
+  # Access to javax.sound.midi
+  module API
+
+    import javax.sound.midi.MidiSystem
+    import javax.sound.midi.MidiDevice
+    import javax.sound.midi.MidiEvent
+    import javax.sound.midi.Receiver
+    import javax.sound.midi.ShortMessage
+    import javax.sound.midi.SysexMessage
+    import javax.sound.midi.Transmitter
+
+    extend self
+
+    # Get all MIDI devices that are available via javax.sound.midi
+    # @return [Array<Hash>] A set of hashes for each available device
+    def get_devices
+      MidiSystem.get_midi_device_info.map do |info|
+        jdevice = MidiSystem.get_midi_device(info)
+        { 
+          :device => jdevice,
+          :id => get_uuid,
+          :name => info.get_name, 
+          :description => info.get_description, 
+          :vendor => info.get_vendor 
+        }
+      end
+    end
+
+    # Get all MIDI inputs that are available via javax.sound.midi
+    # @return [Array<Input>]
+    def get_inputs
+      jinputs = get_devices.select { |device| !device[:device].get_max_transmitters.zero? }
+      jinputs.map { |jinput| Input.new(jinput[:id], jinput[:device], jinput) }
+    end
+
+    # Get all MIDI outputs that are available via javax.sound.midi
+    # @return [Array<Output>]
+    def get_outputs
+      joutputs = get_devices.select { |device| !device[:device].get_max_receivers.zero? }
+      joutputs.map { |joutput| Output.new(joutput[:id], joutput[:device], joutput) } 
+    end
+
+    # Enable the given input device to receive MIDI messages
+    # @param [Java::ComSunMediaSound::MidiInDevice] device
+    # @return [Boolean]
+    def enable_input(device)
+      device.open
+      @transmitter ||= {}
+      @transmitter[device] = device.get_transmitter
+      @transmitter[device].set_receiver(InputReceiver.new)
+      true
+    end
+
+    # Enable the given output to emit MIDI messages
+    # @param [Java::ComSunMediaSound::MidiOutDevice] device
+    # @return [Boolean]
+    def enable_output(device)
+      @receiver ||= {}
+      @receiver[device] = device.get_receiver
+      device.open
+      true
+    end
+
+    # Close the given output device
+    # @param [Java::ComSunMediaSound::MidiOutDevice] device
+    # @return [Boolean]
+    def close_output(device)
+      @receiver[device].close
+      @receiver.delete(device)
+      device.close
+      true
+    end
+
+    # Close the given input device
+    # @param [Java::ComSunMediaSound::MidiInDevice] device
+    # @return [Boolean]
+    def close_input(device)
+      # http://bugs.java.com/bugdatabase/view_bug.do?bug_id=4914667
+      # @transmitter[device].close
+      # device.close
+      @transmitter.delete(device)
+      true
+    end
+
+    # Read any new MIDI messages from the given input device
+    # @param [Java::ComSunMediaSound::MidiInDevice] device
+    # @return [Array<Array<Fixnum>>]
+    def read_input(device)
+      @transmitter[device].get_receiver.read
+    end
+
+    # Write the given MIDI message to the given output device
+    # @param [Java::ComSunMediaSound::MidiOutDevice] device
+    # @param [Array<Fixnum>] data
+    # @return [Boolean]
+    def write_output(device, data)
+      bytes = Java::byte[data.size].new
+      data.each_with_index { |byte, i| bytes.ubyte_set(i, byte) }
+      message = data.first.eql?(0xF0) ? SysexMessage.new : ShortMessage.new
+      message.set_message(bytes, data.length.to_java(:int))
+      @receiver[device].send(message, 0)
+      true
+    end
+
+    private
+
+    # Generate a uuid for a MIDI device
+    # @return [Fixnum]
+    def get_uuid
+      @id ||= -1
+      @id += 1
+    end
+
+    # Input event handler class
+    class InputReceiver
+      
+      include javax.sound.midi.Receiver
+    
+      attr_reader :stream
+
+      def initialize
+        @buffer = []
+      end
+      
+      # Pluck messages from the buffer
+      # @return [Array<Array<Fixnum>>]
+      def read
+        messages = @buffer.dup
+        @buffer.clear
+        messages
+      end
+      
+      # Add a new message to the buffer
+      # @param [Array<Fixnum>] message
+      # @param [Fixnum] timestamp
+      # @return [Array<Array<Fixnum>>]
+      def send(message, timestamp = -1)
+        bytes = if message.respond_to?(:get_packed_message)
+          packed = message.get_packed_message
+          unpack(packed)
+        else
+          string = String.from_java_bytes(message.get_message)
+          string.unpack("C" * string.length)
+        end
+        @buffer << bytes
+      end
+
+      def close
+      end
+      
+      private
+      
+      # @param [String]
+      # @return [Array<Fixnum>]
+      def unpack(message)
+        bytes = []
+        string = message.to_s(16)
+        string = "0#{s}" if string.length.divmod(2).last > 0
+        while string.length > 0
+          string_byte = string.slice!(0,2)
+          bytes << string_byte.hex
+        end
+        bytes.reverse        
+      end
+     
+    end
+
+  end
+
+end

data/lib/midi-jruby/device.rb

@@ -1,73 +1,70 @@
 module MIDIJRuby
 
-  #
-  # Module containing methods used by both input and output devices
-  #
+  # Common methods used by both input and output devices
   module Device
     
-    import javax.sound.midi.MidiSystem
-    import javax.sound.midi.MidiDevice
-    import javax.sound.midi.MidiEvent
-    import javax.sound.midi.Receiver
-
-                # has the device been initialized?
-    attr_reader :enabled,
-                # unique int id 
-                :id,
-                # name property from javax.sound.midi.MidiDevice.Info
-                :name,
-                # description property from javax.sound.midi.MidiDevice.Info
-                :description,
-                # vendor property from javax.sound.midi.MidiDevice.Info
-                :vendor,
-                # :input or :output
-                :type 
+    attr_reader :enabled, # has the device been initialized?
+                :id, # unique int id
+                :name, # name property from javax.sound.midi.MidiDevice.Info
+                :description, # description property from javax.sound.midi.MidiDevice.Info
+                :vendor, # vendor property from javax.sound.midi.MidiDevice.Info
+                :type # :input or :output 
 
     alias_method :enabled?, :enabled
     
-    def initialize(id, device, options = {}, &block)
+    # @param [Fixnum] The uuid for the given device
+    # @param [Java::ComSunMediaSound::MidiInDevice, Java::ComSunMediaSound::MidiOutDevice] device The underlying Java device object
+    # @param [Hash] options
+    # @option options [String] :description
+    # @option options [String] :name
+    # @option options [String] :vendor
+    def initialize(id, device, options = {})
       @name = options[:name]
       @description = options[:description]
       @vendor = options[:vendor]
       @id = id
       @device = device
 
-      # cache the type name so that inspecting the class isn't necessary each time
-      @type = self.class.name.split('::').last.downcase.to_sym
-
+      @type = get_type
       @enabled = false
     end
 
-    # select the first device of type <em>type</em>
-    def self.first(type)
-      all_by_type[type].first
+    # Select the first device of the given direction
+    # @param [Symbol] direction
+    # @return [Input, Output]
+    def self.first(direction)
+      all_by_type[direction].first
     end
 
-    # select the last device of type <em>type</em>
-    def self.last(type)
-      all_by_type[type].last
+    # Select the last device of the given direction
+    # @param [Symbol] direction
+    # @return [Input, Output]
+    def self.last(direction)
+      all_by_type[direction].last
     end
 
-    # a Hash of :input and :output devices
+    # A hash of :input and :output devices
+    # @return [Hash]
     def self.all_by_type
-      available_devices = { :input => [], :output => [] }
-      count = -1
-      MidiSystem.get_midi_device_info.each do |info|
-        device = MidiSystem.get_midi_device(info)
-        opts = { :name => info.get_name, 
-                 :description => info.get_description, 
-                 :vendor => info.get_vendor }
-        available_devices[:output] << Output.new(count += 1, device, opts) unless device.get_max_receivers.zero?
-        available_devices[:input] << Input.new(count += 1, device, opts) unless device.get_max_transmitters.zero?
-      end
-      available_devices
+      @devices ||= { 
+        :input => API.get_inputs, 
+        :output => API.get_outputs
+      }
     end
 
-    # all devices of both types
+    # All devices of both directions
+    # @return [Array<Input, Output>]
     def self.all
       all_by_type.values.flatten
     end
 
+    private
+
+    # @return [String]
+    def get_type
+      self.class.name.split('::').last.downcase.to_sym
+    end
+
   end
 
-end
+end

data/lib/midi-jruby/input.rb

@@ -1,108 +1,58 @@
 module MIDIJRuby
     
-  #
   # Input device class
-  #
   class Input
     
-    import javax.sound.midi.Transmitter
-
     include Device
     
     attr_reader :buffer
-    
-    class InputReceiver
-      
-      include javax.sound.midi.Receiver
-      extend Forwardable
-    
-      attr_reader :stream
-
-      def initialize
-        @buf = []
-      end
-      
-      def read
-        to_return = @buf.dup
-        @buf.clear
-        to_return
-      end
-      
-      def send(msg, timestamp = -1)
-        if msg.respond_to?(:get_packed_msg)
-          m = msg.get_packed_msg
-          @buf << unpack(m)
-        else
-          str = String.from_java_bytes(msg.get_data)
-          arr = str.unpack("C" * str.length)
-          arr.insert(0, msg.get_status)
-          @buf << arr 
-        end
-      end      
-      
-      private
-      
-      def unpack(msg)
-        # there's probably a better way of doing this
-        o = []
-        s = msg.to_s(16)
-        s = "0" + s if s.length.divmod(2).last > 0
-        while s.length > 0 
-          o << s.slice!(0,2).hex
-        end
-        o.reverse        
-      end
-     
-    end
-    
+        
     #
-    # returns an array of MIDI event hashes as such:
+    # An array of MIDI event hashes as such:
     # [
     #   { :data => [144, 60, 100], :timestamp => 1024 },
     #   { :data => [128, 60, 100], :timestamp => 1100 },
     #   { :data => [144, 40, 120], :timestamp => 1200 }
     # ]
     #
-    # the data is an array of Numeric bytes
-    # the timestamp is the number of millis since this input was enabled
+    # The data is an array of numeric bytes
+    # The timestamp is the number of millis since this input was enabled
     #
+    # @return [Array<Hash>]
     def gets
-      until queued_messages?
-      end
-      msgs = queued_messages
+      loop until queued_messages?
+      messages = queued_messages
       @pointer = @buffer.length
-      msgs
+      messages
     end
     alias_method :read, :gets
     
-    # same as gets but returns message data as string of hex digits as such:
+    # Same as Input#gets but returns message data as string of hex digits:
     # [ 
     #   { :data => "904060", :timestamp => 904 },
     #   { :data => "804060", :timestamp => 1150 },
     #   { :data => "90447F", :timestamp => 1300 }
     # ]
     #
-    #
+    # @return [Array<Hash>]
     def gets_s
-      msgs = gets
-      msgs.each { |msg| msg[:data] = numeric_bytes_to_hex_string(msg[:data]) }
-      msgs  
+      messages = gets
+      messages.each { |message| message[:data] = numeric_bytes_to_hex_string(message[:data]) }
+      messages
     end
     alias_method :gets_bytestr, :gets_s
     alias_method :gets_hex, :gets_s
 
-    # enable this the input for use; can be passed a block
+    # Enable this the input for use; can be passed a block
+    # @param [Hash] options
+    # @param [Proc] block
+    # @return [Input] self
     def enable(options = {}, &block)
-      @device.open
-      @transmitter = @device.get_transmitter
-      @transmitter.set_receiver(InputReceiver.new)
-      initialize_buffer
-      @start_time = Time.now.to_f
-      spawn_listener!
+      initialize_input
       @enabled = true
       if block_given?
         begin
-          block.call(self)
+          yield(self)
         ensure
           close
         end
@@ -113,28 +63,46 @@ module MIDIJRuby
     alias_method :open, :enable
     alias_method :start, :enable
 
-    # close this input
+    # Close this input
+    # @return [Boolean]
     def close
       @listener.kill
-      @transmitter.close
-      @device.close
+      API.close_input(@device)
       @enabled = false
     end
     
+    # Select the first input
+    # @return [Input]
     def self.first
       Device.first(:input)  
     end
 
+    # Select the last input
+    # @return [Input]
     def self.last
       Device.last(:input) 
     end
     
+    # All inputs
+    # @return [Array<Input>]
     def self.all
       Device.all_by_type[:input]
     end
     
     private
+
+    # Initialize the input components
+    # @return [Boolean]
+    def initialize_input
+      initialize_buffer
+      API.enable_input(@device)
+      @start_time = Time.now.to_f
+      initialize_listener
+      true
+    end
     
+    # Initialize the input buffer
+    # @return [Boolean]
     def initialize_buffer
       @buffer = []
       @pointer = 0
@@ -144,47 +112,75 @@ module MIDIJRuby
       end
     end
     
+    # Get a timestamp for the current time
+    # @return [Fixnum]
     def now
-      ((Time.now.to_f - @start_time) * 1000)
+      now = Time.now.to_f - @start_time
+      now * 1000
     end
     
-    # give a message its timestamp and package it in a Hash
-    def get_message_formatted(raw, time) 
-      { :data => raw, :timestamp => time }
+    # A hash of a MIDI message and corresponding timestamp
+    # @param [Array<Fixnum>] message
+    # @param [Fixnum] timestamp
+    # @return [Hash]
+    def get_message_formatted(message, timestamp) 
+      { 
+        :data => message, 
+        :timestamp => timestamp
+      }
     end
     
+    # Messages in the buffer
+    # @return [Array<Array<Fixnum>>]
     def queued_messages
       @buffer.slice(@pointer, @buffer.length - @pointer)
     end
     
+    # Are there any new messages in the buffer?
+    # @return [Boolean]
     def queued_messages?
       @pointer < @buffer.length
     end
     
-    # launch a background thread that collects messages
-    def spawn_listener!
-      @listener = Thread.fork do
-        while true          
-          while (msgs = poll_system_buffer).empty?
-            sleep(1.0/1000)
+    # Launch a background thread that collects messages
+    # @return [Thread]
+    def initialize_listener
+      @listener = Thread.new do
+        begin
+          loop do        
+            while (messages = API.read_input(@device)).empty?
+              sleep(1.0/1000)
+            end
+            add_to_buffer(messages) unless messages.empty?
           end
-          populate_local_buffer(msgs) unless msgs.empty?
+        rescue Exception => exception
+          Thread.main.raise(exception)
         end
       end
+      @listener.abort_on_exception = true
+      @listener
+    end
+        
+    # @param [Array<Array<Fixnum>>]
+    # @return [Array<Array<Fixnum>>]
+    def add_to_buffer(messages)
+      @buffer += messages.compact.map do |message| 
+        get_message_formatted(message, now)
+      end
     end
-    
-    def poll_system_buffer
-      @transmitter.get_receiver.read
-    end
-    
-    def populate_local_buffer(msgs)
-      msgs.each { |raw| @buffer << get_message_formatted(raw, now) unless raw.nil? }
-    end
-    
+
+    # Convert an array of numeric bytes to a hex string (eg [0x90, 0x40, 0x40] -> "904040")
+    # @param [Array<Fixnum>] bytes
+    # @return [String]
     def numeric_bytes_to_hex_string(bytes)
-      bytes.map { |b| s = b.to_s(16).upcase; b < 16 ? s = "0" + s : s; s }.join
-    end   
+      string_bytes = bytes.map do |byte| 
+        string = byte.to_s(16).upcase
+        string = "0#{string}" if byte < 0x10
+        string
+      end
+      string_bytes.join
+    end 
    
   end
 
-end
+end

data/lib/midi-jruby/output.rb

@@ -1,61 +1,56 @@
 module MIDIJRuby
   
-  #
   # Output device class
-  #
   class Output
-    import javax.sound.midi.ShortMessage
-    import javax.sound.midi.SysexMessage
     
     include Device
     
-    # close this output
+    # Close this output
+    # @return [Boolean]
     def close
-      @device.close
+      API.close_output(@device)
       @enabled = false
     end
     
-    # sends a MIDI message comprised of a String of hex digits 
+    # Output the given MIDI message
+    # @param [String] data A MIDI message expressed as a string of hex digits 
+    # @return [Boolean]
     def puts_s(data)
-      data = data.dup
-      output = []
-      until (str = data.slice!(0,2)).eql?("")
-        output << str.hex
-      end
-      puts_bytes(*output)
+      bytes = hex_string_to_numeric_bytes(data)
+      puts_bytes(*bytes)
     end
     alias_method :puts_bytestr, :puts_s
     alias_method :puts_hex, :puts_s
 
-    # sends a MIDI messages comprised of Numeric bytes 
+    # Output the given MIDI message
+    # @param [*Fixnum] data A MIDI messages expressed as Numeric bytes 
+    # @return [Boolean]
     def puts_bytes(*data)
-      if data.first.eql?(0xF0)
-        msg = SysexMessage.new
-        msg.set_message(data.to_java(:byte), data.length)
-      else
-        msg = ShortMessage.new
-        msg.set_message(*data)
-      end
-      @device.get_receiver.send(msg, 0)
+      API.write_output(@device, data)
     end
     
-    # send a MIDI message of an indeterminant type
-    def puts(*a)
-      case a.first
-        when Array then puts_bytes(*a.first)
-        when Numeric then puts_bytes(*a)
-        when String then puts_bytestr(*a)
+    # Output the given MIDI message
+    # @param [*Fixnum, *String] args 
+    # @return [Boolean]
+    def puts(*args)
+      case args.first
+        when Array then puts_bytes(*args.first)
+        when Numeric then puts_bytes(*args)
+        when String then puts_bytestr(*args)
       end
     end
     alias_method :write, :puts
     
-    # enable this device; also takes a block
+    # Enable this device; also takes a block
+    # @param [Hash] options
+    # @param [Proc] block
+    # @return [Output]
     def enable(options = {}, &block)
-      @device.open
+      API.enable_output(@device)
       @enabled = true
-      unless block.nil?
+      if block_given?
         begin
-          block.call(self)
+          yield(self)
         ensure
           close
         end
@@ -66,17 +61,38 @@ module MIDIJRuby
     alias_method :open, :enable
     alias_method :start, :enable
     
+    # Select the first output
+    # @return [Output]
     def self.first
       Device.first(:output) 
     end
 
+    # Select the last output
+    # @return [Output]
     def self.last
       Device.last(:output)  
     end
     
+    # All outputs
+    # @return [Array<Output>]
     def self.all
       Device.all_by_type[:output]
     end
+
+    private
+
+    # Convert a hex string to numeric bytes (eg "904040" -> [0x90, 0x40, 0x40])
+    # @param [String] string
+    # @return [Array<Fixnum>]
+    def hex_string_to_numeric_bytes(string)
+      string = string.dup
+      bytes = []
+      until (string_byte = string.slice!(0,2)) == ""
+        bytes << string_byte.hex
+      end
+      bytes
+    end
+
   end
   
-end
+end

data/lib/midi-jruby.rb

@@ -1,15 +1,23 @@
-require 'java'
-require 'forwardable' 
-
-#
-# Set of modules and classes for interacting with javax.sound.midi
+# Realtime MIDI IO in JRuby using the javax.sound.midi API
 #
+# Ari Russo
+# (c) 2011-2014
+# Licensed under Apache 2.0
+
+# libs
+require "java"
+require "forwardable" 
+
+# modules
+require "midi-jruby/api"
+require "midi-jruby/device"
+
+# classes
+require "midi-jruby/input"
+require "midi-jruby/output"
+
 module MIDIJRuby
   
-    VERSION = "0.0.12"
+  VERSION = "0.1.1"
        
 end
-
-require 'midi-jruby/device'
-require 'midi-jruby/input'
-require 'midi-jruby/output'

data/test/helper.rb

@@ -0,0 +1,60 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + "/../lib"
+
+require "test/unit"
+require "mocha/test_unit"
+require "shoulda-context"
+require "midi-jruby"
+
+module TestHelper
+
+  extend self
+
+  # http://stackoverflow.com/questions/8148898/java-midi-in-mac-osx-broken
+  def sysex_ok?
+    ENV["_system_name"] != "OSX"
+  end
+
+  def bytestrs_to_ints(arr)
+    data = arr.map { |m| m[:data] }.join
+    output = []
+    until (bytestr = data.slice!(0,2)).eql?("")
+      output << bytestr.hex
+    end
+    output    	
+  end
+
+  def numeric_messages
+    messages = [
+      [0x90, 100, 100], # note on
+      [0x90, 43, 100], # note on
+      [0x90, 76, 100], # note on
+      [0x90, 60, 100], # note on
+      [0x80, 100, 100] # note off
+    ]
+    if sysex_ok?
+      messages << [0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7]
+    end
+    messages
+  end
+
+  def string_messages
+    messages = [
+      "906440", # note on
+      "804340" # note off
+    ]
+    if sysex_ok?
+      messages << "F04110421240007F0041F7"
+    end
+    messages
+  end
+
+  def input
+    MIDIJRuby::Input.first
+  end
+
+  def output
+    MIDIJRuby::Output.first 
+  end
+
+end

data/test/input_buffer_test.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class MIDIJRuby::InputBufferTest < Test::Unit::TestCase
+
+  context "MIDIJRuby" do
+
+    setup do
+      @input = TestHelper.input.open
+      @output = TestHelper.output.open
+      @input.buffer.clear
+      @pointer = 0
+    end
+
+    teardown do
+      @input.close
+      @output.close
+    end
+
+    context "Source#buffer" do
+
+      setup do
+        @messages = TestHelper.numeric_messages
+        @messages_arr = @messages.inject(&:+).flatten
+        @received_arr = []
+      end
+
+      should "have the correct messages in the buffer" do
+        bytes = []
+        @messages.each do |message|
+          p "sending: #{message}"
+          @output.puts(message)
+          bytes += message
+
+          sleep(1)
+
+          buffer = @input.buffer.map { |m| m[:data] }.flatten
+          p "received: #{buffer.to_s}"
+          assert_equal(bytes, buffer)
+        end
+        assert_equal(bytes.length, @input.buffer.map { |m| m[:data] }.flatten.length)
+      end
+
+    end
+
+  end
+end

data/test/io_test.rb

@@ -0,0 +1,80 @@
+require "helper"
+
+class MIDIJRuby::IOTest < Test::Unit::TestCase
+
+  # These tests assume that TestOutput is connected to TestInput
+  context "MIDIJRuby" do
+
+    setup do
+      @input = TestHelper.input.open
+      @output = TestHelper.output.open
+      @input.buffer.clear
+      @pointer = 0
+    end
+
+    teardown do
+      @input.close
+      @output.close
+    end
+
+    context "full IO" do
+
+      context "using Arrays" do
+
+        setup do
+          @messages = TestHelper.numeric_messages
+          @messages_arr = @messages.inject(&:+).flatten
+          @received_arr = []
+        end
+
+        should "do IO" do
+          @messages.each do |message|
+
+            p "sending: #{message}"
+
+            @output.puts(message)
+            sleep(1)
+            received = @input.gets.map { |m| m[:data] }.flatten
+
+            p "received: #{received}"
+
+            assert_equal(@messages_arr.slice(@pointer, received.length), received)
+            @pointer += received.length
+            @received_arr += received
+          end
+          assert_equal(@messages_arr.length, @received_arr.length)
+        end
+      end
+
+      context "using byte Strings" do
+
+        setup do
+          @messages = TestHelper.string_messages
+          @messages_str = @messages.join
+          @received_str = ""
+        end
+
+        should "do IO" do
+          @messages.each do |message|
+
+            p "sending: #{message}"
+
+            @output.puts(message)
+            sleep(1)
+            received = @input.gets_bytestr.map { |m| m[:data] }.flatten.join
+            p "received: #{received}"
+
+            assert_equal(@messages_str.slice(@pointer, received.length), received)
+            @pointer += received.length
+            @received_str += received
+          end
+          assert_equal(@messages_str, @received_str)
+        end
+
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,62 +1,54 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: midi-jruby
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.12
+version: !ruby/object:Gem::Version
+  version: 0.1.1
 platform: ruby
-authors: 
-  - Ari Russo
-autorequire: 
+authors:
+- Ari Russo
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2012-03-04 00:00:00 -05:00
-default_executable: 
+date: 2014-09-28 00:00:00.000000000 Z
 dependencies: []
-
-description: Simple MIDI wrapper for realtime IO in JRuby.  Uses javax.sound.midi. Note that this library requires JRuby to be run in '1.9 mode'
-email: 
-  - ari.russo@gmail.com
+description: Realtime MIDI IO with JRuby using the javax.sound.midi API
+email:
+- ari.russo@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - lib/midi-jruby.rb
-  - lib/midi-jruby/device.rb
-  - lib/midi-jruby/input.rb
-  - lib/midi-jruby/output.rb
-  - LICENSE
-  - README.rdoc
-has_rdoc: true
+files:
+- lib/midi-jruby.rb
+- lib/midi-jruby/api.rb
+- lib/midi-jruby/device.rb
+- lib/midi-jruby/input.rb
+- lib/midi-jruby/output.rb
+- test/helper.rb
+- test/input_buffer_test.rb
+- test/io_test.rb
+- LICENSE
+- README.md
 homepage: http://github.com/arirusso/midi-jruby
-licenses: []
-
-post_install_message: 
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message:
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.3.6
+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-jruby
-rubygems_version: 1.5.1
-signing_key: 
-specification_version: 3
-summary: Simple MIDI wrapper for realtime IO in JRuby
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: Realtime MIDI IO with JRuby
 test_files: []
-

data/README.rdoc

@@ -1,52 +0,0 @@
-= midi-jruby
-
-== Summary
-
-Simple MIDI wrapper for realtime IO in JRuby. Uses javax.sound.midi.
-
-In the interest of allowing people on other platforms to utilize your code, you should consider using {unimidi}[http://github.com/arirusso/unimidi].  Unimidi is a platform independent wrapper which implements midi-jruby for users who are using jruby.  
-
-== Features
-
-* Input and output on multiple devices concurrently
-* Agnostically handle different MIDI Message types (including SysEx)
-* Timestamped input events
-
-== Install
-
-* gem install midi-jruby
-
-== Usage 
-
-This library requires that JRuby be run in '1.9 mode'.  This is normally done by passing --1.9 to JRuby at the command line
-	
-== Examples
-
-* {input}[http://github.com/arirusso/midi-jruby/blob/master/examples/input.rb]
-* {output}[http://github.com/arirusso/midi-jruby/blob/master/examples/output.rb]
-
-== Issues
-
-There is an issue that causes javax.sound.midi not to be able to send SysEx messages in some OSX Snow Leopard versions.
-	
-== Tests
-
-Use
-
-    jruby --1.9 -S rake test
-
-* please see {test/config.rb}[http://github.com/arirusso/midi-jruby/blob/master/test/config.rb] before running tests
-
-== Documentation
-
-* {rdoc}[http://rdoc.info/gems/midi-jruby]
-
-== 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