midi-nibbler 0.1.1 → 0.2.1

data/lib/nibbler/session.rb

@@ -0,0 +1,134 @@
+module Nibbler
+ 
+  # A parser session
+  #
+  # Holds on to data that is not relevant to the parser between calls. For instance,
+  # past messages, rejected bytes
+  #
+  class Session
+
+    extend Forwardable
+
+    attr_reader :messages,
+                :processed,
+                :rejected
+    
+    def_delegators :@parser, :buffer            
+    def_delegator :clear_buffer, :buffer, :clear
+    def_delegator :clear_processed, :processed, :clear
+    def_delegator :clear_rejected, :rejected, :clear
+    def_delegator :clear_messages, :messages, :clear
+
+    # @param [Hash] options
+    # @option options [Boolean] :timestamps Whether to report timestamps
+    def initialize(options = {})
+      @timestamps = options[:timestamps] || false
+      @callbacks, @processed, @rejected, @messages = [], [], [], []
+      @parser = Parser.new(options)    
+    end
+    
+    # @return [Array<Object>]
+    def all_messages
+      @messages | @fragmented_messages
+    end
+    
+    # The buffer as a single hex string
+    # @return [String]
+    def buffer_s
+      buffer.join
+    end
+    alias_method :buffer_hex, :buffer_s
+
+    # Clear the parser buffer
+    def clear_buffer
+      buffer.clear
+    end
+
+    # Clear the message log
+    def clear_messages
+      @messages.clear
+    end
+    
+    # Convert messages to hashes with timestamps
+    def use_timestamps
+      if !@timestamps
+        @messages = @messages.map do |message|
+          { 
+            :messages => message, 
+            :timestamp => nil
+          }
+        end
+        @timestamps = true
+      end
+    end
+
+    # Parse some input
+    # @param [*Object] args
+    # @param [Hash] options (can be included as the last arg)
+    # @option options [Time] :timestamp A timestamp to store with the messages that result
+    # @return [Array<Object>, Hash]
+    def parse(*args)
+      options = args.last.kind_of?(Hash) ? args.pop : {}
+      timestamp = options[:timestamp]
+
+      use_timestamps if !timestamp.nil? 
+
+      result = process(args)
+      log(result, timestamp)  
+    end    
+    
+    private
+
+    # Process the input
+    # @param [Array<Object>] input
+    # @return [Hash]
+    def process(input)
+      queue = HexProcessor.process(input)
+      @parser.process(queue)
+    end
+
+    # @param [Hash] parser_report
+    # @param [Time] timestamp
+    # @return [Array<Object>, Hash]
+    def log(parser_report, timestamp)
+      num = log_message(parser_report[:messages], :timestamp => timestamp)
+      @processed += parser_report[:processed]
+      @rejected += parser_report[:rejected]
+      get_output(num)
+    end
+        
+    # @param [Array<Object>] messages The MIDI messages to log
+    # @return [Fixnum] The number of MIDI messages logged
+    def log_message(messages, options = {})
+      if @timestamps
+        messages_for_log = messages.count == 1 ? messages.first : messages
+        @messages << { 
+          :messages => messages_for_log, 
+          :timestamp => options[:timestamp] 
+        }     
+      else
+        @messages += messages
+      end
+      messages.count
+    end
+
+    # A report on the given number of most recent messages
+    #
+    # If timestamps are being used, will be a hash of messages and timestamp,
+    # otherwise just the messages
+    #
+    # The messages type will vary depending on the number of messages that were parsed:
+    # 0 messages: nil
+    # 1 message: the message
+    # >1 message: an array of messages
+    #
+    # @param [Fixnum] num The number of new messages to report
+    # @return [Array<Object>, Hash] 
+    def get_output(num)
+      messages = @messages.last(num)
+      messages.count < 2 ? messages.first : messages 
+    end
+    
+  end
+  
+end

data/lib/nibbler/type_conversion.rb

@@ -1,11 +1,14 @@
-#!/usr/bin/env ruby
-#
 module Nibbler
  
-  # this is a helper for converting nibbles and bytes
+  # A helper for converting between different types of nibbles and bytes
   module TypeConversion
+
+    extend self
     
-    def self.hex_chars_to_numeric_bytes(nibbles)
+    # Converts an array of hex nibble strings to numeric bytes
+    # @param [Array<String>] nibbles
+    # @return [Array<Fixnum>]
+    def hex_chars_to_numeric_bytes(nibbles)
       nibbles = nibbles.dup
       # get rid of last nibble if there's an odd number
       # it will be processed later anyway
@@ -18,16 +21,20 @@ module Nibbler
       bytes
     end
     
-    # converts a string of hex digits to bytes
-    def self.hex_str_to_hex_chars(str)
-      str.split(//)    
+    # Converts a string of hex digits to string nibbles
+    # @param [String] string
+    # @return [Array<String>]
+    def hex_str_to_hex_chars(string)
+      string.split(//)    
     end
     
-    def self.numeric_byte_to_hex_chars(num)
+    # Converts a numeric byte to an array of hex nibble strings
+    # @param [Fixnum] num
+    # @return [Array<String>]
+    def numeric_byte_to_hex_chars(num)
       [((num & 0xF0) >> 4), (num & 0x0F)].map { |n| n.to_s(16) }      
     end
 
-    
   end
   
-end
+end

data/test/helper.rb

@@ -1,11 +1,5 @@
-#!/usr/bin/env ruby
-
 dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + '/../lib'
-
-require 'test/unit'
-require 'nibbler'
+$LOAD_PATH.unshift dir + "/../lib"
 
-module TestHelper
-  
-end
+require "test/unit"
+require "nibbler"

data/test/{test_hex_char_array_filter.rb → hex_processor_test.rb}

@@ -1,61 +1,56 @@
-#!/usr/bin/env ruby
+require "helper"
 
-require 'helper'
-
-class HexCharArrayFilterTest < Test::Unit::TestCase
-
-  include Nibbler
-  include TestHelper
+class Nibbler::HexProcessorTest < Test::Unit::TestCase
   
   def test_to_nibbles_array_mixed
-    filter = HexCharArrayFilter.new
+    processor = Nibbler::HexProcessor
     array = [0x90, "90", "9"]
-    nibbles = filter.send(:process, array)
+    nibbles = processor.send(:process, array)
     assert_equal([0x90, "90", "9"], array)
     assert_equal(["9", "0", "9", "0", "9"], nibbles)     
   end
   
   def test_to_nibbles_mixed
-    filter = HexCharArrayFilter.new
+    processor = Nibbler::HexProcessor
     array = [0x90, "90", "9"]
-    nibbles = filter.send(:process, *array)
+    nibbles = processor.send(:process, *array)
     assert_equal([0x90, "90", "9"], array)
     assert_equal(["9", "0", "9", "0", "9"], nibbles)     
   end
 
   def test_to_nibbles_numeric
-    filter = HexCharArrayFilter.new
+    processor = Nibbler::HexProcessor
     num = 0x90
-    nibbles = filter.send(:process, num)
+    nibbles = processor.send(:process, num)
     assert_equal(0x90, num)
     assert_equal(["9", "0"], nibbles)     
   end                
 
   def test_to_nibbles_string
-    filter = HexCharArrayFilter.new
+    processor = Nibbler::HexProcessor
     str = "904050"
-    nibbles = filter.send(:process, str)
+    nibbles = processor.send(:process, str)
     assert_equal("904050", str)
     assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)     
   end
     
-  def test_filter_numeric
-    filter = HexCharArrayFilter.new
+  def test_processor_numeric
+    processor = Nibbler::HexProcessor
     badnum = 560
-    output = filter.send(:filter_numeric, badnum)
+    output = processor.send(:filter_numeric, badnum)
     assert_equal(560, badnum)
     assert_equal(nil, output)     
     goodnum = 50
-    output = filter.send(:filter_numeric, goodnum)
+    output = processor.send(:filter_numeric, goodnum)
     assert_equal(50, goodnum)
     assert_equal(50, output)     
   end
   
-  def test_filter_string
-    filter = HexCharArrayFilter.new
+  def test_processor_string
+    processor = Nibbler::HexProcessor
     str = "(0xAdjskla#(#"
-    outp = filter.send(:filter_string, str)
+    outp = processor.send(:filter_string, str)
     assert_equal("0ADA", outp)
   end
   
-end
+end

data/test/midi_message_test.rb

@@ -0,0 +1,126 @@
+require "helper"
+require "nibbler/midi-message"
+
+class Nibbler::MIDIMessageTest < Test::Unit::TestCase
+
+  def test_note_off
+    lib = Nibbler::MIDIMessage
+    message = lib.note_off(0, 0x40, 0x40)
+    assert_equal(MIDIMessage::NoteOff, message.class)
+    assert_equal(0, message.channel)
+    assert_equal(0x40, message.note)
+    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  
+  
+  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  
+  
+  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)    
+  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)  
+  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  
+    
+  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   
+  
+  def test_system_exclusive_command
+    lib = Nibbler::MIDIMessage
+    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)   
+    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   
+    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)    
+  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    
+
+  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    
+
+  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    
+  
+  def test_system_realtime
+    nibbler = Nibbler.new
+    message = nibbler.parse(0xF8)
+    assert_equal(MIDIMessage::SystemRealtime, message.class)
+    assert_equal(8, message.id)
+  end        
+   
+end

data/test/midilib_test.rb

@@ -0,0 +1,131 @@
+require "helper"
+require "nibbler/midilib"
+
+class Nibbler::MidilibTest < Test::Unit::TestCase
+   
+  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)  
+  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  
+  
+  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  
+  
+  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)    
+  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)  
+  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  
+    
+  def test_pitch_bend
+    # to-do handle the midilib lsb/msb
+    # right now the second data byte is being thrown away
+    lib = Nibbler::Midilib
+    message = lib.pitch_bend(0x0, 0x20, 0x00)
+    assert_equal(MIDI::PitchBend, message.class)
+    assert_equal(0, message.channel)
+    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)   
+    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    
+
+  def test_start
+    lib = Nibbler::Midilib
+    message = lib.system_realtime(0xA)
+    assert_equal(MIDI::Start, message.class)
+  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    
+  
+  def test_sense
+    lib = Nibbler::Midilib
+    message = lib.system_realtime(0xE)
+    assert_equal(MIDI::ActiveSense, message.class)
+  end       
+
+  def test_reset
+    lib = Nibbler::Midilib
+    message = lib.system_realtime(0xF)
+    assert_equal(MIDI::SystemReset, message.class)
+  end       
+    
+end