midi-nibbler 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bffa717264483d31e4f80d8be90a7d2908a003b
-  data.tar.gz: d62d625eebbfa98b39acef4620cc87a85912d8bf
+  metadata.gz: 022b8e486f76d1621f5d3a73ad6eb3dff9764b6a
+  data.tar.gz: a030a1248bf74224ae98c85138ca146bbf07d1d0
 SHA512:
-  metadata.gz: d2dd5f9de0c90bff1137a274369569692d3451782ce16687132413cb4869abd634354d29b98306b56d79f03f6d1ba30a4d4b901f92d5af535ac6dfda5f96a1e5
-  data.tar.gz: 91602c10acafb0014f072a501c27c62a0f9f2681622e138b0ff3d643e9a357bd3101be0cf17e3ba9f00a4a91c1d762bb3d071416efa43360ba1cced86c831546
+  metadata.gz: 0fee2f393f46e64144d0f0c12a9421e6bcf86781bcf870b4d9af586cd3e284266f27678ffa985d6d80730e0e865ccfbddfe838729ff40c3810f49562497bcdb0
+  data.tar.gz: 418ece8a8a607b38c350342aa197ba94e636b3e138b0e40e66a2e87499fc4356a9257722d0d0307a8ecb36fb025e691e9cfeaef72b2d56e12ca106c2182a8b8b

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2011-2014 Ari Russo
+Copyright 2011-2015 Ari Russo
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/README.md

@@ -1,9 +1,9 @@
 # Nibbler
 
-![nibbler](http://img17.imageshack.us/img17/1713/dogwithsynth.jpg)
+![nibbler](http://i.imgur.com/4BFZPJY.png)
 
 Parse MIDI Messages
-	
+
 ## Install
 
 `gem install midi-nibbler`
@@ -16,12 +16,12 @@ or using Bundler, add this to your Gemfile
 
 ```ruby
 require 'nibbler'
-  
+
 nibbler = Nibbler.new
 ```
 
 Enter a message piece by piece
-  
+
 ```ruby
 nibbler.parse("90")
   => nil
@@ -30,31 +30,31 @@ nibbler.parse("40")
   => nil
 
 nibbler.parse("40")
-  => #<MIDIMessage::NoteOn:0x98c9818 
-       @channel=0, 
-       @data=[64, 100], 
-       @name="C3", 
-       @note=64, 
-       @status=[9, 0], 
-       @velocity=100, 
+  => #<MIDIMessage::NoteOn:0x98c9818
+       @channel=0,
+       @data=[64, 100],
+       @name="C3",
+       @note=64,
+       @status=[9, 0],
+       @velocity=100,
        @verbose_name="Note On: C3">
 ```
-  
+
 Enter a message all at once
-  
+
 ```ruby
 nibbler.parse("904040")
-  
-  => #<MIDIMessage::NoteOn:0x98c9818 
-        @channel=0, 
-        @data=[64, 100], 
-        @name="C3", 
-        @note=64, 
-        @status=[9, 0], 
-        @velocity=100, 
+
+  => #<MIDIMessage::NoteOn:0x98c9818
+        @channel=0,
+        @data=[64, 100],
+        @name="C3",
+        @note=64,
+        @status=[9, 0],
+        @velocity=100,
         @verbose_name="Note On: C3">
 ```
- 
+
 Use bytes
 
 ```ruby
@@ -63,14 +63,14 @@ nibbler.parse(0x90, 0x40, 0x40)
 ```
 
 You can use nibbles in string format
- 
+
 ```ruby
 nibbler.parse("9", "0", "4", "0", "4", "0")
   => #<MIDIMessage::NoteOn:0x98c9818 ...>
 ```
 
 Interchange the different types
-  
+
 ```ruby
 nibbler.parse("9", "0", 0x40, 64)
   => #<MIDIMessage::NoteOn:0x98c9818 ...>
@@ -84,7 +84,7 @@ nibbler.parse(0x40, 64)
 ```
 
 Look at the messages we've parsed
-  
+
 ```ruby
 nibbler.messages
   => [#<MIDIMessage::NoteOn:0x98c9804 ...>
@@ -92,7 +92,7 @@ nibbler.messages
 ```
 
 Add an incomplete message
-  
+
 ```ruby
 nibbler.parse("9")
 nibbler.parse("40")
@@ -107,7 +107,7 @@ nibbler.buffer
 nibbler.buffer_s
   => "940"
 ```
-  
+
 Pass in a timestamp
 
 ```ruby
@@ -119,7 +119,7 @@ Nibbler defaults to generate [midi-message](http://github.com/arirusso/midi-mess
 
 ```ruby
 Nibbler.new(:message_lib => :midilib)
-  
+
 nibbler.parse("9", "0", 0x40, "40")
   => "0: ch 00 on 40 40"
 ```
@@ -136,4 +136,4 @@ nibbler.parse("9", "0", 0x40, "40")
 
 Apache 2.0, See the file LICENSE
 
-Copyright (c) 2011-2014 Ari Russo
+Copyright (c) 2011-2015 Ari Russo

data/lib/nibbler.rb

@@ -1,16 +1,19 @@
 #
+# Nibbler
 # Parse MIDI Messages
-# (c)2011-2014 Ari Russo and licensed under the Apache 2.0 License
+# (c)2011-2015 Ari Russo and licensed under the Apache 2.0 License
 #
 
 # libs
 require "forwardable"
 
 # modules
-require "nibbler/hex_processor"
+require "nibbler/data_processor"
 require "nibbler/type_conversion"
 
 # classes
+require "nibbler/message_builder"
+require "nibbler/message_library"
 require "nibbler/parser"
 require "nibbler/session"
 
@@ -19,7 +22,7 @@ require "nibbler/session"
 #
 module Nibbler
 
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 
   # Shortcut to a new parser session
   def self.new(*a, &block)

data/lib/nibbler/{hex_processor.rb → data_processor.rb}

@@ -1,47 +1,53 @@
-module Nibbler  
-  
+module Nibbler
+
   # Accepts various types of input and returns an array of hex digit chars
-  module HexProcessor
+  #
+  # Ideally this would output Integer objects. However, given that Ruby numerics 0x0 and 0x00 result in the same
+  # object (0 Integer), this would limit the parser to only working with bytes instead of both nibbles and bytes.
+  #
+  # For example, if the input were "5" then the processor would return an ambiguous 0x5
+  #
+  module DataProcessor
 
     extend self
-       
+
     # Accepts various types of input and returns an array of hex digit chars
     # Invalid input is disregarded
     #
-    # @param [*String, *Fixnum] args
+    # @param [*String, *Integer] args
     # @return [Array<String>] An array of hex string nibbles eg "6", "a"
     def process(*args)
-      args.map { |arg| convert(arg) }.flatten.compact.map(&:upcase) 
+      args.map { |arg| convert(arg) }.flatten.compact.map(&:upcase)
     end
-    
+
     private
 
     # Convert a single value to hex chars
-    # @param [Array<Fixnum>, Array<String>, Fixnum, String] value
+    # @param [Array<Integer>, Array<String>, Integer, String] value
     # @return [Array<String>]
     def convert(value)
       case value
         when Array then value.map { |arr| process(*arr) }.reduce(:+)
         when String then TypeConversion.hex_str_to_hex_chars(filter_string(value))
-        when Fixnum then TypeConversion.numeric_byte_to_hex_chars(filter_numeric(value))
+        when Integer then TypeConversion.numeric_byte_to_hex_chars(filter_numeric(value))
       end
     end
-    
+
     # Limit the given number to bytes usable in MIDI ie values (0..240)
     # returns nil if the byte is outside of that range
-    # @param [Fixnum] num
-    # @return [Fixnum, nil]
+    # @param [Integer] num
+    # @return [Integer, nil]
     def filter_numeric(num)
       num if (0x00..0xFF).include?(num)
     end
-    
+
     # Only return valid hex string characters
     # @param [String] string
     # @return [String]
     def filter_string(string)
       string.gsub(/[^0-9a-fA-F]/, "").upcase
     end
-  
+
   end
 
 end

data/lib/nibbler/message_builder.rb

@@ -0,0 +1,84 @@
+module Nibbler
+
+  class MessageBuilder
+
+    CHANNEL_MESSAGE = [
+      {
+        :status => 0x8,
+        :name => :note_off,
+        :nibbles => 6
+      },
+      {
+        :status => 0x9,
+        :name => :note_on,
+        :nibbles => 6
+      },
+      {
+        :status => 0xA,
+        :name => :polyphonic_aftertouch,
+        :nibbles => 6
+      },
+      {
+        :status => 0xB,
+        :name => :control_change,
+        :nibbles => 6
+      },
+      {
+        :status => 0xC,
+        :name => :program_change,
+        :nibbles => 4
+      },
+      {
+        :status => 0xD,
+        :name => :channel_aftertouch,
+        :nibbles => 4
+      },
+      {
+        :status => 0xE,
+        :name => :pitch_bend,
+        :nibbles => 6
+      }
+    ].freeze
+
+    SYSTEM_MESSAGE = [
+      {
+        :status => 0x1..0x6,
+        :name => :system_common,
+        :nibbles => 6
+      },
+      {
+        :status => 0x8..0xF,
+        :name => :system_realtime,
+        :nibbles => 2
+      }
+    ].freeze
+
+    attr_reader :num_nibbles, :name
+
+    def self.build_system_exclusive(library, *message_data)
+      library.system_exclusive(*message_data)
+    end
+
+    def self.for_system_message(library, status)
+      type = SYSTEM_MESSAGE.find { |type| type[:status].cover?(status) }
+      new(library, type[:name], type[:nibbles])
+    end
+
+    def self.for_channel_message(library, status)
+      type = CHANNEL_MESSAGE.find { |type| type[:status] == status }
+      new(library, type[:name], type[:nibbles])
+    end
+
+    def initialize(library, name, num_nibbles)
+      @library = library
+      @name = name
+      @num_nibbles = num_nibbles
+    end
+
+    def build(*message_data)
+      @library.send(@name, *message_data)
+    end
+
+  end
+
+end

data/lib/nibbler/message_library.rb

@@ -0,0 +1,21 @@
+module Nibbler
+
+  class MessageLibrary
+
+    # MIDI message object library adapter
+    # @param [Symbol] lib The MIDI message library module eg MIDIMessage or Midilib
+    # @return [Module]
+    def self.adapter(lib = nil)
+      case lib
+      when :midilib then
+        require "nibbler/midilib"
+        ::Nibbler::Midilib
+      else
+        require "nibbler/midi-message"
+        ::Nibbler::MIDIMessage
+      end
+    end
+
+  end
+
+end

data/lib/nibbler/parser.rb

@@ -4,143 +4,165 @@ module Nibbler
 
     attr_reader :buffer
 
-    # @param [Hash] options
-    # @option options [Symbol] :message_lib
-    def initialize(options = {})
-      @running_status = nil
+    def initialize(library)
+      @library = library
+      @running_status = RunningStatus.new
       @buffer = []
-      @iterator = 0
-
-      initialize_message_library(options[:message_lib])
     end
 
-    # @param [Array<String, Fixnum>] nibbles
+    # Process the given nibbles and add them to the buffer
+    # @param [Array<String, Integer>] nibbles
     # @return [Hash]
     def process(nibbles)
-      report = { 
-        :messages => [], 
-        :processed => [], 
-        :rejected => [] 
-      }          
-      @iterator = 0      
-      @buffer += nibbles  
-      while @iterator <= (@buffer.length - 1)
-        # iterate through nibbles until a status message is found        
-        # see if there really is a message there
-        populate_current
-        # current is the current piece of the buffer we"re dealing with
-        unless (processed = nibbles_to_message).nil?
-          # if it"s a real message, reject previous nibbles
-          report[:rejected] += @buffer.slice(0, @iterator)          
-          # and record it          
-          @buffer = @current # current now has the remaining nibbles for next pass
-          @current = nil # reset current
-          @iterator = 0 # reset iterator
+      report = {
+        :messages => [],
+        :processed => [],
+        :rejected => []
+      }
+      pointer = 0
+      @buffer += nibbles
+      # Iterate through nibbles in the buffer until a status message is found
+      while pointer <= (@buffer.length - 1)
+        # fragment is the piece of the buffer to look at
+        fragment = get_fragment(pointer)
+        # See if there really is a message there
+        unless (processed = nibbles_to_message(fragment)).nil?
+          # if fragment contains a real message, reject the nibbles that precede it
+          report[:rejected] += @buffer.slice(0, pointer)
+          # and record it
+          @buffer = fragment.dup # fragment now has the remaining nibbles for next pass
+          fragment = nil # Reset fragment
+          pointer = 0 # Reset iterator
           report[:messages] << processed[:message]
-          report[:processed] += processed[:processed]          
+          report[:processed] += processed[:processed]
         else
-          @running_status = nil
-          @iterator += 1
-        end         
+          @running_status.cancel
+          pointer += 1
+        end
       end
       report
     end
 
+    # If possible, convert the given fragment to a MIDI message
+    # @param [Array<String>] fragment A fragment of data eg ["9", "0", "4", "0", "5", "0"]
     # @return [Hash, nil]
-    def nibbles_to_message
-      if @current.length >= 2
-        nibbles = @current.slice(0..1).map(&:hex)
-        compute_message(nibbles)           
+    def nibbles_to_message(fragment)
+      if fragment.length >= 2
+        # convert the part of the fragment to start with to a numeric
+        slice = fragment.slice(0..1).map(&:hex)
+        compute_message(slice, fragment)
       end
     end
 
     private
 
-    # @param [Array<Fixnum>] nibbles
+    # Attempt to convert the given nibbles into a MIDI message
+    # @param [Array<Integer>] nibbles
     # @return [Hash, nil]
-    def compute_message(nibbles)
+    def compute_message(nibbles, fragment)
       case nibbles[0]
-      when 0x8 then lookahead(6) { |status_2, bytes| @message.note_off(status_2, bytes[1], bytes[2]) }
-      when 0x9 then lookahead(6) { |status_2, bytes| @message.note_on(status_2, bytes[1], bytes[2]) }
-      when 0xA then lookahead(6) { |status_2, bytes| @message.polyphonic_aftertouch(status_2, bytes[1], bytes[2]) }
-      when 0xB then lookahead(6) { |status_2, bytes| @message.control_change(status_2, bytes[1], bytes[2]) }
-      when 0xC then lookahead(4) { |status_2, bytes| @message.program_change(status_2, bytes[1]) }
-      when 0xD then lookahead(4) { |status_2, bytes| @message.channel_aftertouch(status_2, bytes[1]) }
-      when 0xE then lookahead(6) { |status_2, bytes| @message.pitch_bend(status_2, bytes[1], bytes[2]) }
-      when 0xF then 
+      when 0x8..0xE then lookahead(fragment, MessageBuilder.for_channel_message(@library, nibbles[0]))
+      when 0xF then
         case nibbles[1]
-        when 0x0 then lookahead_sysex { |bytes| @message.system_exclusive(*bytes) }
-        when 0x1..0x6 then lookahead(6, :recursive => true) { |status_2, bytes| @message.system_common(status_2, bytes[1], bytes[2]) }
-        when 0x8..0xF then lookahead(2) { |status_2, bytes| @message.system_realtime(status_2) }
+        when 0x0 then lookahead_for_sysex(fragment)
+        else lookahead(fragment, MessageBuilder.for_system_message(@library, nibbles[1]), :recursive => true)
         end
       else
-        use_running_status if possible_running_status? 
+        lookahead_using_running_status(fragment) if @running_status.possible?
       end
     end
 
-    # Choose a MIDI message object library
-    def initialize_message_library(lib)
-      @message = case lib
-      when :midilib then    
-        require "nibbler/midilib"
-        ::Nibbler::Midilib
-      else      
-        require "nibbler/midi-message"    
-        ::Nibbler::MIDIMessage    
-      end
+    # Attempt to convert the fragment to a MIDI message using the given fragment and cached running status
+    # @param [Array<String>] fragment A fragment of data eg ["4", "0", "5", "0"]
+    # @return [Hash, nil]
+    def lookahead_using_running_status(fragment)
+      lookahead(fragment, @running_status[:message_builder], :offset => @running_status[:offset], :status_nibble_2 => @running_status[:status_nibble_2])
     end
 
-    def possible_running_status?
-      !@running_status.nil?
+    # Get the data in the buffer for the given pointer
+    # @param [Integer] pointer
+    # @return [Array<String>]
+    def get_fragment(pointer)
+      @buffer[pointer, (@buffer.length - pointer)]
     end
 
-    def use_running_status
-      lookahead(@running_status[:num], :status_nibble => @running_status[:status_nibble], &@running_status[:callback])
-    end  
-
-    def populate_current
-      @current = (@buffer[@iterator, (@buffer.length - @iterator)])
-    end
-
-    def lookahead(num, options = {}, &callback)
-      # do we have enough nibbles for num bytes?
-      if @current.size >= num
+    # If the given fragment has at least the given number of nibbles, use it to build a hash that can be used
+    # to build a MIDI message
+    #
+    # @param [Integer] num_nibbles
+    # @param [Array<String>] fragment
+    # @param [Hash] options
+    # @option options [String] :status_nibble_2
+    # @option options [Boolean] :recursive
+    # @return [Hash, nil]
+    def lookahead(fragment, message_builder, options = {})
+      offset = options.fetch(:offset, 0)
+      num_nibbles = message_builder.num_nibbles + offset
+      if fragment.size >= num_nibbles
         # if so shift those nibbles off of the array and call block with them
-        nibbles = @current.slice!(0, num)
-        status_nibble ||= options[:status_nibble] || nibbles[1]  
+        nibbles = fragment.slice!(0, num_nibbles)
+        status_nibble_2 ||= options[:status_nibble_2] || nibbles[1]
 
-        # send the nibbles to the block as bytes         
-        # return the evaluated block and the remaining nibbles       
+        # send the nibbles to the block as bytes
+        # return the evaluated block and the remaining nibbles
         bytes = TypeConversion.hex_chars_to_numeric_bytes(nibbles)
+        bytes = bytes[1..-1] if options[:status_nibble_2].nil?
 
-        # record the current situation in case running status comes up next round
-        @running_status = { 
-          :callback => callback, 
-          :num => num - 2, 
-          :status_nibble => status_nibble 
-        }
+        # record the fragment situation in case running status comes up next round
+        @running_status.set(offset - 2, message_builder, status_nibble_2)
+
+        message_args = [status_nibble_2.hex]
+        message_args += bytes if num_nibbles > 2
 
+        message = message_builder.build(*message_args)
         {
-          :message => yield(status_nibble.hex, bytes),
+          :message => message,
           :processed => nibbles
         }
-      elsif num > 0 && !!options[:recursive]
-        lookahead(num - 2, options, &callback)
+      elsif num_nibbles > 0 && !!options[:recursive]
+        lookahead(fragment, message_builder, options.merge({ :offset => offset - 2 }))
       end
     end
 
-    def lookahead_sysex(&block)
-      @running_status = nil
-
-      bytes = TypeConversion.hex_chars_to_numeric_bytes(@current)
+    def lookahead_for_sysex(fragment)
+      @running_status.cancel
+      bytes = TypeConversion.hex_chars_to_numeric_bytes(fragment)
       unless (index = bytes.index(0xF7)).nil?
+        message_data = bytes.slice!(0, index + 1)
+        message = MessageBuilder.build_system_exclusive(@library, *message_data)
         {
-          :message => yield(bytes.slice!(0, index + 1)),
-          :processed => @current.slice!(0, (index + 1) * 2)
+          :message => message,
+          :processed => fragment.slice!(0, (index + 1) * 2)
         }
       end
     end
 
+    class RunningStatus
+
+      extend Forwardable
+
+      def_delegators :@state, :[]
+
+      def cancel
+        @state = nil
+      end
+
+      # Is there an active cached running status?
+      # @return [Boolean]
+      def possible?
+        !@state.nil?
+      end
+
+      def set(offset, message_builder, status_nibble_2)
+        @state = {
+          :message_builder => message_builder,
+          :offset => offset,
+          :status_nibble_2 => status_nibble_2
+        }
+      end
+
+    end
+
   end
 
 end