midi-nibbler 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8413384db29c1e35d128afb0d982cfd866472c8
-  data.tar.gz: 1652fbc29119c0d0cb0f97f4e7c66167cf906253
+  metadata.gz: 12e9cb3c3684c88cfaa6def382fd591872380563
+  data.tar.gz: 6f842d364c13786f66d8696ff05e8fc2a02c0ae9
 SHA512:
-  metadata.gz: 66610505ed6b6111864ca1467d90ab72366bdb874ec3f401b56608e857ba2139b7fe3fe8144fee7bceafe5ef4c7eb6ce16e4f931399fccb998cc3682bfb58f52
-  data.tar.gz: 228e832b552cac66f79b46d2ea9cd6bf1edd67d7535e791e00ec4621a1a74180f6f365ee661268c87936379e06c370abd7adeccc2feefa54438b401eaf6b08a2
+  metadata.gz: 418f23d23ece2aca433e6fa7bca758f347627cea9c35fde0c6276bc5eba9af0fdb5799ba8305fabdceac8a03707e3e79596a3b52821d70f160a62930775a0a84
+  data.tar.gz: d9bba92335832c7138bebb7ce99aad3ad9ae898abd0e394aa17c9a8307c947ef65440fedb170b924173c5b70614b71672bf0a51ffb3df3f7faa6c7b9f4db32a4

data/lib/nibbler.rb

@@ -1,7 +1,7 @@
 #
 # Parse MIDI Messages
 # (c)2011-2014 Ari Russo and licensed under the Apache 2.0 License
-# 
+#
 
 # libs
 require "forwardable"
@@ -18,8 +18,8 @@ require "nibbler/session"
 # Parse MIDI Messages
 #
 module Nibbler
-  
-  VERSION = "0.2.1"
+
+  VERSION = "0.2.2"
 
   # Shortcut to a new parser session
   def self.new(*a, &block)
@@ -27,4 +27,3 @@ module Nibbler
   end
 
 end
-	

data/test/helper.rb

@@ -1,5 +1,5 @@
 dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + "/../lib"
 
-require "test/unit"
+require "minitest/autorun"
 require "nibbler"

data/test/hex_processor_test.rb

@@ -1,21 +1,21 @@
 require "helper"
 
-class Nibbler::HexProcessorTest < Test::Unit::TestCase
-  
+class Nibbler::HexProcessorTest < Minitest::Test
+
   def test_to_nibbles_array_mixed
     processor = Nibbler::HexProcessor
     array = [0x90, "90", "9"]
     nibbles = processor.send(:process, array)
     assert_equal([0x90, "90", "9"], array)
-    assert_equal(["9", "0", "9", "0", "9"], nibbles)     
+    assert_equal(["9", "0", "9", "0", "9"], nibbles)
   end
-  
+
   def test_to_nibbles_mixed
     processor = Nibbler::HexProcessor
     array = [0x90, "90", "9"]
     nibbles = processor.send(:process, *array)
     assert_equal([0x90, "90", "9"], array)
-    assert_equal(["9", "0", "9", "0", "9"], nibbles)     
+    assert_equal(["9", "0", "9", "0", "9"], nibbles)
   end
 
   def test_to_nibbles_numeric
@@ -23,34 +23,34 @@ class Nibbler::HexProcessorTest < Test::Unit::TestCase
     num = 0x90
     nibbles = processor.send(:process, num)
     assert_equal(0x90, num)
-    assert_equal(["9", "0"], nibbles)     
-  end                
+    assert_equal(["9", "0"], nibbles)
+  end
 
   def test_to_nibbles_string
     processor = Nibbler::HexProcessor
     str = "904050"
     nibbles = processor.send(:process, str)
     assert_equal("904050", str)
-    assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)     
+    assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)
   end
-    
+
   def test_processor_numeric
     processor = Nibbler::HexProcessor
     badnum = 560
     output = processor.send(:filter_numeric, badnum)
     assert_equal(560, badnum)
-    assert_equal(nil, output)     
+    assert_equal(nil, output)
     goodnum = 50
     output = processor.send(:filter_numeric, goodnum)
     assert_equal(50, goodnum)
-    assert_equal(50, output)     
+    assert_equal(50, output)
   end
-  
+
   def test_processor_string
     processor = Nibbler::HexProcessor
     str = "(0xAdjskla#(#"
     outp = processor.send(:filter_string, str)
     assert_equal("0ADA", outp)
   end
-  
+
 end

data/test/midi_message_test.rb

@@ -1,7 +1,7 @@
 require "helper"
 require "nibbler/midi-message"
 
-class Nibbler::MIDIMessageTest < Test::Unit::TestCase
+class Nibbler::MIDIMessageTest < Minitest::Test
 
   def test_note_off
     lib = Nibbler::MIDIMessage
@@ -9,118 +9,118 @@ class Nibbler::MIDIMessageTest < Test::Unit::TestCase
     assert_equal(MIDIMessage::NoteOff, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)  
+    assert_equal(0x40, message.velocity)
   end
-  
+
   def test_note_on
     lib = Nibbler::MIDIMessage
     message = lib.note_on(0x0, 0x40, 0x40)
     assert_equal(MIDIMessage::NoteOn, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)  
-  end  
-  
+    assert_equal(0x40, message.velocity)
+  end
+
   def test_polyphonic_aftertouch
     lib = Nibbler::MIDIMessage
     message = lib.polyphonic_aftertouch(0x1, 0x40, 0x40)
     assert_equal(MIDIMessage::PolyphonicAftertouch, message.class)
     assert_equal(1, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.value)      
-  end  
-  
+    assert_equal(0x40, message.value)
+  end
+
   def test_control_change
     lib = Nibbler::MIDIMessage
     message = lib.control_change(0x2, 0x20, 0x20)
     assert_equal(MIDIMessage::ControlChange, message.class)
     assert_equal(message.channel, 2)
     assert_equal(0x20, message.index)
-    assert_equal(0x20, message.value)    
+    assert_equal(0x20, message.value)
   end
-  
+
   def test_program_change
     lib = Nibbler::MIDIMessage
     message = lib.program_change(0x3, 0x40)
     assert_equal(MIDIMessage::ProgramChange, message.class)
     assert_equal(3, message.channel)
-    assert_equal(0x40, message.program)  
+    assert_equal(0x40, message.program)
   end
-  
+
   def test_channel_aftertouch
     lib = Nibbler::MIDIMessage
     message = lib.channel_aftertouch(0x3, 0x50)
     assert_equal(MIDIMessage::ChannelAftertouch, message.class)
     assert_equal(3, message.channel)
-    assert_equal(0x50, message.value)  
-  end  
-    
+    assert_equal(0x50, message.value)
+  end
+
   def test_pitch_bend
     lib = Nibbler::MIDIMessage
     message = lib.pitch_bend(0x0, 0x20, 0x00) # center
     assert_equal(MIDIMessage::PitchBend, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x20, message.low)
-    assert_equal(0x00, message.high)  
-  end   
-  
+    assert_equal(0x00, message.high)
+  end
+
   def test_system_exclusive_command
     lib = Nibbler::MIDIMessage
-    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)   
+    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
     assert_equal(MIDIMessage::SystemExclusive::Command, message.class)
     assert_equal([0xF0, [0x41, 0x10, 0x42], 0x12, [0x40, 0x00, 0x7F], [0x00], 0x41, 0xF7], message.to_a)
     assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], message.to_bytes)
     assert_equal("F04110421240007F0041F7", message.to_hex_s)
   end
-  
+
   def test_system_exclusive_request
     lib = Nibbler::MIDIMessage
-    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)   
+    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
     assert_equal(MIDIMessage::SystemExclusive::Request, message.class)
     assert_equal([0xF0, [0x41, 0x10, 0x42], 0x11, [0x40, 0x00, 0x7F], [0x00, 0x00, 0x00], 0x41, 0xF7], message.to_a)
     assert_equal([0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x41, 0xF7], message.to_bytes)
     assert_equal("F04110421140007F00000041F7", message.to_hex_s)
   end
-  
+
   def test_system_exclusive_node
     lib = Nibbler::MIDIMessage
     message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-    node = message.node   
+    node = message.node
     assert_equal(MIDIMessage::SystemExclusive::Node, node.class)
     assert_equal(0x41, node.manufacturer_id)
     assert_equal(0x42, node.model_id)
-    assert_equal(0x10, node.device_id)    
+    assert_equal(0x10, node.device_id)
   end
-   
+
   def test_system_common_generic_3_bytes
     lib = Nibbler::MIDIMessage
     message = lib.system_common(0x1, 0x50, 0xA0)
     assert_equal(MIDIMessage::SystemCommon, message.class)
     assert_equal(1, message.status[1])
     assert_equal(0x50, message.data[0])
-    assert_equal(0xA0, message.data[1])  
-  end    
+    assert_equal(0xA0, message.data[1])
+  end
 
   def test_system_common_generic_2_bytes
     nibbler = Nibbler.new
     message = nibbler.parse(0xF1, 0x50)
     assert_equal(MIDIMessage::SystemCommon, message.class)
     assert_equal(1, message.status[1])
-    assert_equal(0x50, message.data[0])  
-  end    
+    assert_equal(0x50, message.data[0])
+  end
 
   def test_system_common_generic_1_byte
     nibbler = Nibbler.new
     message = nibbler.parse(0xF1)
     assert_equal(MIDIMessage::SystemCommon, message.class)
     assert_equal(1, message.status[1])
-  end    
-  
+  end
+
   def test_system_realtime
     nibbler = Nibbler.new
     message = nibbler.parse(0xF8)
     assert_equal(MIDIMessage::SystemRealtime, message.class)
     assert_equal(8, message.id)
-  end        
-   
+  end
+
 end

data/test/midilib_test.rb

@@ -1,60 +1,60 @@
 require "helper"
 require "nibbler/midilib"
 
-class Nibbler::MidilibTest < Test::Unit::TestCase
-   
+class Nibbler::MidilibTest < Minitest::Test
+  
   def test_note_off
     lib = Nibbler::Midilib
     message = lib.note_off(0x0, 0x40, 0x40)
     assert_equal(MIDI::NoteOff, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)  
+    assert_equal(0x40, message.velocity)
   end
-  
+
   def test_note_on
     lib = Nibbler::Midilib
     message = lib.note_on(0x0, 0x40, 0x40)
     assert_equal(MIDI::NoteOn, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)  
-  end  
-  
+    assert_equal(0x40, message.velocity)
+  end
+
   def test_polyphonic_aftertouch
     lib = Nibbler::Midilib
     message = lib.polyphonic_aftertouch(0x1, 0x40, 0x40)
     assert_equal(MIDI::PolyPressure, message.class)
     assert_equal(1, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.pressure)      
-  end  
-  
+    assert_equal(0x40, message.pressure)
+  end
+
   def test_control_change
     lib = Nibbler::Midilib
     message = lib.control_change(0x2, 0x20, 0x20)
     assert_equal(MIDI::Controller, message.class)
     assert_equal(message.channel, 2)
     assert_equal(0x20, message.controller)
-    assert_equal(0x20, message.value)    
+    assert_equal(0x20, message.value)
   end
-  
+
   def test_program_change
     lib = Nibbler::Midilib
     message = lib.program_change(0x3, 0x40)
     assert_equal(MIDI::ProgramChange, message.class)
     assert_equal(3, message.channel)
-    assert_equal(0x40, message.program)  
+    assert_equal(0x40, message.program)
   end
-  
+
   def test_channel_aftertouch
     lib = Nibbler::Midilib
     message = lib.channel_aftertouch(0x3, 0x50)
     assert_equal(MIDI::ChannelPressure, message.class)
     assert_equal(3, message.channel)
-    assert_equal(0x50, message.pressure)  
-  end  
-    
+    assert_equal(0x50, message.pressure)
+  end
+
   def test_pitch_bend
     # to-do handle the midilib lsb/msb
     # right now the second data byte is being thrown away
@@ -62,70 +62,70 @@ class Nibbler::MidilibTest < Test::Unit::TestCase
     message = lib.pitch_bend(0x0, 0x20, 0x00)
     assert_equal(MIDI::PitchBend, message.class)
     assert_equal(0, message.channel)
-    assert_equal(0x20, message.value) 
+    assert_equal(0x20, message.value)
   end
-  
+
   def test_system_exclusive
     lib = Nibbler::Midilib
-    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)   
+    message = lib.system_exclusive(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
     assert_equal(MIDI::SystemExclusive, message.class)
     assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], message.data)
   end
-  
+
   def test_song_pointer
     lib = Nibbler::Midilib
     message = lib.system_common(0x2, 0xF0)
     assert_equal(MIDI::SongPointer, message.class)
     assert_equal(0xF0, message.pointer)
   end
-  
+
   def test_song_select
     lib = Nibbler::Midilib
     message = lib.system_common(0x3, 0xA0)
     assert_equal(MIDI::SongSelect, message.class)
     assert_equal(0xA0, message.song)
   end
-  
+
   def test_tune_request
     lib = Nibbler::Midilib
     message = lib.system_common(0x6)
     assert_equal(MIDI::TuneRequest, message.class)
   end
-  
+
   def test_clock
     lib = Nibbler::Midilib
     message = lib.system_realtime(0x8)
     assert_equal(MIDI::Clock, message.class)
-  end    
+  end
 
   def test_start
     lib = Nibbler::Midilib
     message = lib.system_realtime(0xA)
     assert_equal(MIDI::Start, message.class)
-  end     
-  
+  end
+
   def test_continue
     lib = Nibbler::Midilib
     message = lib.system_realtime(0xB)
     assert_equal(MIDI::Continue, message.class)
   end
-  
+
   def test_stop
     lib = Nibbler::Midilib
     message = lib.system_realtime(0xC)
     assert_equal(MIDI::Stop, message.class)
-  end    
-  
+  end
+
   def test_sense
     lib = Nibbler::Midilib
     message = lib.system_realtime(0xE)
     assert_equal(MIDI::ActiveSense, message.class)
-  end       
+  end
 
   def test_reset
     lib = Nibbler::Midilib
     message = lib.system_realtime(0xF)
     assert_equal(MIDI::SystemReset, message.class)
-  end       
-    
+  end
+
 end

data/test/parser_buffer_test.rb

@@ -1,13 +1,13 @@
 require "helper"
 
-class Nibbler::BufferTest < Test::Unit::TestCase
+class Nibbler::BufferTest < Minitest::Test
 
   def test_buffer_nibble_str
     nibbler = Nibbler.new
     nibbler.parse("9")
     assert_equal(["9"], nibbler.buffer)
   end
-    
+
   def test_buffer_single_byte
     nibbler = Nibbler.new
     nibbler.parse(0x90)
@@ -19,48 +19,48 @@ class Nibbler::BufferTest < Test::Unit::TestCase
     nibbler.parse("90")
     assert_equal(["9", "0"], nibbler.buffer)
   end
-  
+
   def test_buffer_single_byte_in_array
     nibbler = Nibbler.new
     nibbler.parse([0x90])
     assert_equal(["9", "0"], nibbler.buffer)
   end
-  
+
   def test_buffer_two_bytes
     nibbler = Nibbler.new
     nibbler.parse(0x90, 0x40)
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)    
+    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
   end
 
   def test_buffer_two_bytes_str
     nibbler = Nibbler.new
     nibbler.parse("90", "40")
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)    
+    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
   end
 
   def test_buffer_two_bytes_single_str
     nibbler = Nibbler.new
     nibbler.parse("9040")
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)    
+    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
   end
-  
+
   def test_buffer_two_bytes_mixed
     nibbler = Nibbler.new
     nibbler.parse("90", 0x40)
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)    
-  end  
+    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
+  end
 
   def test_buffer_nibble_and_byte_mixed
     nibbler = Nibbler.new
     nibbler.parse("9", 0x40)
-    assert_equal(["9", "4", "0"], nibbler.buffer)    
-  end  
-  
+    assert_equal(["9", "4", "0"], nibbler.buffer)
+  end
+
   def test_buffer_stepped
     nibbler = Nibbler.new
     nibbler.parse("9")
     nibbler.parse(0x40)
-    assert_equal(["9", "4", "0"], nibbler.buffer)    
+    assert_equal(["9", "4", "0"], nibbler.buffer)
   end
-    
+
 end

data/test/parser_rejected_test.rb

@@ -1,12 +1,12 @@
 require "helper"
 
-class Nibbler::ParserRejectedTest < Test::Unit::TestCase
-  
+class Nibbler::ParserRejectedTest < Minitest::Test
+
   def test_leading_chars
     nibbler = Nibbler.new
     msg = nibbler.parse("0", "9", "04", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)        
-    assert_equal(["0"], nibbler.rejected)   
+    assert_equal(::MIDIMessage::NoteOn, msg.class)
+    assert_equal(["0"], nibbler.rejected)
   end
 
   def test_2_leading_chars
@@ -14,21 +14,21 @@ class Nibbler::ParserRejectedTest < Test::Unit::TestCase
     msg = nibbler.parse("1", "0", "9", "04", "040")
     assert_equal(["1", "0"], nibbler.rejected)
   end
-    
+
   def test_leading_string
     nibbler = Nibbler.new
     msg = nibbler.parse("10", "9", "04", "040")
     assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal(["1", "0"], nibbler.rejected)
   end
-  
+
   def test_long_leading_string
     nibbler = Nibbler.new
     msg = nibbler.parse("000001000010", "9", "04", "040")
     assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal("000001000010".split(//), nibbler.rejected)
   end
-  
+
   def test_long_leading_string_overlap
     nibbler = Nibbler.new
     msg = nibbler.parse("000001000010090", "4", "040")
@@ -49,12 +49,12 @@ class Nibbler::ParserRejectedTest < Test::Unit::TestCase
     assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal(["6", "0", "3", "0"], nibbler.rejected)
   end
-  
+
   def test_3_leading_numbers
     nibbler = Nibbler.new
     msg = nibbler.parse(0x00, 0x30, "9", "04", "040")
     assert_equal(::MIDIMessage::NoteOn, msg.class)
     assert_equal(["0", "0", "3", "0"], nibbler.rejected)
-  end  
-  
+  end
+
 end

data/test/parser_test.rb

@@ -1,18 +1,18 @@
 require "helper"
 
-class Nibbler::ParserTest < Test::Unit::TestCase
-  
+class Nibbler::ParserTest < Minitest::Test
+
   def test_lookahead
     parser = Nibbler::Parser.new
     num = 6
     parser.instance_variable_set("@buffer", ["9", "0", "4", "0", "5", "0"])
-    parser.send(:populate_current)    
+    parser.send(:populate_current)
     output = parser.send(:lookahead, num) { |nibble_2, bytes| [nibble_2, bytes] }
     assert_equal([0,[0x90, 0x40, 0x50]], output[:message])
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])    
+    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
     assert_equal([], parser.instance_variable_get("@current"))
   end
-    
+
   def test_lookahead_trailing
     parser = Nibbler::Parser.new
     num = 6
@@ -20,86 +20,86 @@ class Nibbler::ParserTest < Test::Unit::TestCase
     parser.send(:populate_current)
     output = parser.send(:lookahead, num) { |nibble_2, bytes| [nibble_2, bytes] }
     assert_equal([0,[0x90, 0x40, 0x50]], output[:message])
-    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])    
+    assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
     assert_equal(["5", "0"], parser.instance_variable_get("@current"))
   end
-  
+
   def test_lookahead_too_short
     parser = Nibbler::Parser.new
     num = 6
     parser.instance_variable_set("@buffer", ["9", "0", "4"])
     parser.send(:populate_current)
-    output = parser.send(:lookahead, num) do |nibble_2, bytes| 
+    output = parser.send(:lookahead, num) do |nibble_2, bytes|
       {
         :message => nibble_2,
-        :processed => bytes 
+        :processed => bytes
       }
     end
 
-    assert_nil output      
+    assert_nil output
     assert_equal(["9", "0", "4"], parser.instance_variable_get("@current"))
   end
-  
+
   def test_lookahead_sysex
     parser = Nibbler::Parser.new
     parser.instance_variable_set("@buffer", "F04110421240007F0041F750".split(//))
     parser.send(:populate_current)
     output = parser.send(:lookahead_sysex) { |b| b }
     assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], output[:message])
-    assert_equal("F04110421240007F0041F7".split(//), output[:processed])    
+    assert_equal("F04110421240007F0041F7".split(//), output[:processed])
     assert_equal(["5", "0"], parser.instance_variable_get("@current"))
   end
-  
+
   def test_lookahead_sysex_too_short
     parser = Nibbler::Parser.new
     parser.instance_variable_set("@buffer", ["9", "0", "4"])
     parser.send(:populate_current)
     output = parser.send(:lookahead_sysex) { |b| b }
-    
-    assert_nil output     
+
+    assert_nil output
     assert_equal(["9", "0", "4"], parser.instance_variable_get("@current"))
   end
-  
+
   def test_process
     parser = Nibbler::Parser.new
     short = ["9", "0", "4", "0", "5", "0", "5", "0"]
     output = parser.send(:process, short)
-    
+
     assert_equal(::MIDIMessage::NoteOn, output[:messages].first.class)
     assert_equal(["5", "0"], parser.buffer)
     assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
   end
-  
+
   def test_process_running_status
     parser = Nibbler::Parser.new
     two_msgs = ["9", "0", "4", "0", "5", "0", "4", "0", "6", "0"]
     output = parser.send(:process, two_msgs)
-    
-    assert_not_nil output
+
+    refute_nil output
     assert_equal(::MIDIMessage::NoteOn, output[:messages][0].class)
     #assert_equal(::MIDIMessage::NoteOn, output[:messages][1].class)
     assert_equal([], parser.buffer)
     assert_equal(["9", "0", "4", "0", "5", "0", "4", "0", "6", "0"], output[:processed])
   end
-  
+
   def test_process_multiple_overlapping_calls
     parser = Nibbler::Parser.new
     short = ["9", "0", "4", "0", "5", "0", "9", "0"]
     short2 = ["3", "0", "2", "0", "1", "0"]
-    
+
     output = parser.send(:process, short)
 
-    assert_not_nil output
+    refute_nil output
     assert_equal(::MIDIMessage::NoteOn, output[:messages].first.class)
     assert_equal(["9", "0"], parser.buffer)
     assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
-    
+
     output2 = parser.send(:process, short2)
 
-    assert_not_nil output2
+    refute_nil output2
     assert_equal(::MIDIMessage::NoteOn, output2[:messages].first.class)
     assert_equal(["1", "0"], parser.buffer)
-    assert_equal(["9", "0", "3", "0", "2", "0"], output2[:processed])    
+    assert_equal(["9", "0", "3", "0", "2", "0"], output2[:processed])
   end
 
   def test_nibbles_to_message_leading
@@ -112,7 +112,7 @@ class Nibbler::ParserTest < Test::Unit::TestCase
     assert_nil output
     assert_equal(["5", "0", "9", "0", "4", "0", "5", "0"], parser.buffer)
   end
-  
+
   def test_nibbles_to_message_trailing
     parser = Nibbler::Parser.new
     short = ["9", "0", "4", "0", "5", "0", "5", "0"]
@@ -120,12 +120,12 @@ class Nibbler::ParserTest < Test::Unit::TestCase
     parser.send(:populate_current)
     output = parser.send(:nibbles_to_message)
 
-    assert_not_nil output
+    refute_nil output
     assert_equal(::MIDIMessage::NoteOn, output[:message].class)
     assert_equal(["5", "0"], parser.instance_variable_get("@current"))
     assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
   end
-  
+
   def test_nibbles_to_message
     parser = Nibbler::Parser.new
     short = ["9", "0", "4", "0", "5", "0", "5", "0"]
@@ -133,12 +133,12 @@ class Nibbler::ParserTest < Test::Unit::TestCase
     parser.send(:populate_current)
     output = parser.send(:nibbles_to_message)
 
-    assert_not_nil output
+    refute_nil output
     assert_equal(::MIDIMessage::NoteOn, output[:message].class)
     assert_equal(["5", "0"], parser.instance_variable_get("@current"))
     assert_equal(["9", "0", "4", "0", "5", "0"], output[:processed])
   end
-  
+
   def test_nibbles_to_message_running_status
     parser = Nibbler::Parser.new
     short = ["9", "0", "4", "0", "5", "0"]
@@ -146,19 +146,19 @@ class Nibbler::ParserTest < Test::Unit::TestCase
     parser.send(:populate_current)
     output = parser.send(:nibbles_to_message)
 
-    assert_not_nil output
+    refute_nil output
     assert_equal(::MIDIMessage::NoteOn, output[:message].class)
-    
+
     running_status = ["5", "0", "6", "0"]
     parser.instance_variable_set("@buffer", running_status)
     parser.send(:populate_current)
     output = parser.send(:nibbles_to_message)
 
-    assert_not_nil output
+    refute_nil output
     assert_equal(::MIDIMessage::NoteOn, output[:message].class)
     assert_equal(["5", "0", "6", "0"], output[:processed])
   end
-  
+
   def test_nibbles_to_message_sysex
     parser = Nibbler::Parser.new
     sysex = "F04110421240007F0041F750".split(//)
@@ -166,23 +166,18 @@ class Nibbler::ParserTest < Test::Unit::TestCase
     parser.send(:populate_current)
     output = parser.send(:nibbles_to_message)
 
-    assert_not_nil output
+    refute_nil output
     assert_equal(::MIDIMessage::SystemExclusive::Command, output[:message].class)
     assert_equal(["5", "0"], parser.instance_variable_get("@current"))
     assert_equal("F04110421240007F0041F7".split(//), output[:processed])
-  end  
-  
+  end
+
   def test_message_library
-    parser = nil
-    assert_nothing_raised Exception do
-      parser = Nibbler::Parser.new(:message_lib => :midilib)
-    end
+    parser = Nibbler::Parser.new(:message_lib => :midilib)
     assert_equal Nibbler::Midilib, parser.instance_variable_get("@message")
 
-    assert_nothing_raised Exception do
-      parser = Nibbler::Parser.new
-    end
+    parser = Nibbler::Parser.new
     assert_equal Nibbler::MIDIMessage, parser.instance_variable_get("@message")
   end
-            
+
 end

data/test/session_test.rb

@@ -1,135 +1,135 @@
 require "helper"
 
-class Nibbler::SessionTest < Test::Unit::TestCase
-    
+class Nibbler::SessionTest < Minitest::Test
+
   def test_varying_length_strings
     session = Nibbler::Session.new
     message = session.parse("9", "04", "040")
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::NoteOn, message.class)
   end
-  
+
   def test_note_off
     session = Nibbler::Session.new
     message = session.parse(0x80, 0x40, 0x40)
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::NoteOff, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)  
+    assert_equal(0x40, message.velocity)
   end
-  
+
   def test_note_on
     session = Nibbler::Session.new
     message = session.parse(0x90, 0x40, 0x40)
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::NoteOn, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.velocity)  
-  end  
-  
+    assert_equal(0x40, message.velocity)
+  end
+
   def test_timestamp
     session = Nibbler::Session.new
     stamp = Time.now.to_i
     report = session.parse(0x90, 0x40, 0x40, :timestamp => stamp)
     message = report[:messages]
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::NoteOn, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x40, message.note)
     assert_equal(0x40, message.velocity)
-    assert_equal(stamp, report[:timestamp])      
+    assert_equal(stamp, report[:timestamp])
   end
-  
+
   def test_polyphonic_aftertouch
     session = Nibbler::Session.new
     message = session.parse(0xA1, 0x40, 0x40)
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::PolyphonicAftertouch, message.class)
     assert_equal(1, message.channel)
     assert_equal(0x40, message.note)
-    assert_equal(0x40, message.value)      
-  end  
-  
+    assert_equal(0x40, message.value)
+  end
+
   def test_control_change
     session = Nibbler::Session.new
     message = session.parse(0xB2, 0x20, 0x20)
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::ControlChange, message.class)
     assert_equal(message.channel, 2)
     assert_equal(0x20, message.index)
-    assert_equal(0x20, message.value)    
+    assert_equal(0x20, message.value)
   end
-  
+
   def test_program_change
     session = Nibbler::Session.new
     message = session.parse(0xC3, 0x40)
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::ProgramChange, message.class)
     assert_equal(3, message.channel)
-    assert_equal(0x40, message.program)  
+    assert_equal(0x40, message.program)
   end
-  
+
   def test_channel_aftertouch
     session = Nibbler::Session.new
     message = session.parse(0xD3, 0x50)
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::ChannelAftertouch, message.class)
     assert_equal(3, message.channel)
-    assert_equal(0x50, message.value)  
-  end  
-    
+    assert_equal(0x50, message.value)
+  end
+
   def test_pitch_bend
     session = Nibbler::Session.new
     message = session.parse(0xE0, 0x20, 0x00) # center
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::PitchBend, message.class)
     assert_equal(0, message.channel)
     assert_equal(0x20, message.low)
-    assert_equal(0x00, message.high)  
-  end   
-   
+    assert_equal(0x00, message.high)
+  end
+
   def test_system_common_generic_3_bytes
     session = Nibbler::Session.new
     message = session.parse(0xF1, 0x50, 0xA0)
 
-    assert_not_nil message
+    refute_nil message
     assert_equal(MIDIMessage::SystemCommon, message.class)
     assert_equal(1, message.status[1])
     assert_equal(0x50, message.data[0])
-    assert_equal(0xA0, message.data[1])  
-  end    
+    assert_equal(0xA0, message.data[1])
+  end
 
   def test_system_common_generic_2_bytes
     session = Nibbler::Session.new
     message = session.parse(0xF1, 0x50)
     assert_equal(MIDIMessage::SystemCommon, message.class)
     assert_equal(1, message.status[1])
-    assert_equal(0x50, message.data[0])  
-  end    
+    assert_equal(0x50, message.data[0])
+  end
 
   def test_system_common_generic_1_byte
     session = Nibbler::Session.new
     message = session.parse(0xF1)
     assert_equal(MIDIMessage::SystemCommon, message.class)
     assert_equal(1, message.status[1])
-  end    
-  
+  end
+
   def test_system_realtime
     session = Nibbler::Session.new
     message = session.parse(0xF8)
     assert_equal(MIDIMessage::SystemRealtime, message.class)
     assert_equal(8, message.id)
   end
-                 
+
 end

data/test/type_conversion_test.rb

@@ -1,29 +1,29 @@
 require "helper"
 
-class Nibbler::TypeConversionTest < Test::Unit::TestCase
-  
-  def test_hex_chars_to_numeric_bytes  
+class Nibbler::TypeConversionTest < Minitest::Test
+
+  def test_hex_chars_to_numeric_bytes
     nibbles = ["4", "5", "9", "3"]
     bytes = Nibbler::TypeConversion.hex_chars_to_numeric_bytes(nibbles)
-    
+
     assert_equal(["4", "5", "9", "3"], nibbles)
-    assert_equal([0x45, 0x93], bytes) 
+    assert_equal([0x45, 0x93], bytes)
   end
-  
+
   def test_hex_str_to_hex_chars
     str = "904050"
     nibbles = Nibbler::TypeConversion.send(:hex_str_to_hex_chars, str)
-    
+
     assert_equal("904050", str)
-    assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)    
+    assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)
   end
-  
+
   def test_numeric_byte_to_hex_chars
     num = 0x90
     nibbles = Nibbler::TypeConversion.send(:numeric_byte_to_hex_chars, num)
-    
+
     assert_equal(0x90, num)
-    assert_equal(["9", "0"], nibbles)     
-  end         
-              
+    assert_equal(["9", "0"], nibbles)
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: midi-nibbler
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-30 00:00:00.000000000 Z
+date: 2015-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: midi-message