midi-nibbler 0.0.4 → 0.0.5

data/README.rdoc

@@ -20,13 +20,13 @@ Parse MIDI Messages
 
 Enter a message piece by piece
   
-  p nibbler.parse("90")
+  nibbler.parse("90")
   nil
 
-  p nibbler.parse("40")
+  nibbler.parse("40")
   nil
 
-  p nibbler.parse("40")
+  nibbler.parse("40")
   # #<MIDIMessage::NoteOn:0x98c9818 
   #  @channel=0, 
   #  @data=[64, 100], 
@@ -38,7 +38,7 @@ Enter a message piece by piece
   
 Enter a message all at once
   
-  p nibbler.parse("904040")
+  nibbler.parse("904040")
   
   # #<MIDIMessage::NoteOn:0x98c9818 
   #  @channel=0, 
@@ -51,53 +51,61 @@ Enter a message all at once
   
 Use bytes
   
-  p nibbler.parse(0x90, 0x40, 0x40)
+  nibbler.parse(0x90, 0x40, 0x40)
   #<MIDIMessage::NoteOn:0x98c9818 ...>
     
 You can use nibbles in string format
   
-  p nibbler.parse("9", "0", "4", "0", "4", "0")
+  nibbler.parse("9", "0", "4", "0", "4", "0")
   #<MIDIMessage::NoteOn:0x98c9818 ...>
   
 Interchange the different types
   
-  p nibbler.parse("9", "0", 0x40, 64)
+  nibbler.parse("9", "0", 0x40, 64)
   #<MIDIMessage::NoteOn:0x98c9818 ...>
   
 Use running status
 
-  p nibbler.parse(0x40, 64)
+  nibbler.parse(0x40, 64)
   #<MIDIMessage::NoteOn:0x98c9818 ...>
   
 Look at the messages we've parsed
   
-  p nibbler.messages
+  nibbler.messages
   [#<MIDIMessage::NoteOn:0x98c9804 ...>
    #<MIDIMessage::NoteOn:0x98c9811 ...>]
   
 Add an incomplete message
   
-  p nibbler.parse("9")
-  p nibbler.parse("40")
+  nibbler.parse("9")
+  nibbler.parse("40")
   
 See progress
   
-  p nibbler.buffer
+  nibbler.buffer
   ["9", "4", "0"]
   
-  p nibbler.buffer_hex
+  nibbler.buffer_s
   "940"
   
 Pass in a timestamp
 
-  p nibbler.parse("904040", :timestamp => Time.now.to_i)
-  # { :messages=> #<MIDIMessage::NoteOn:0x92f4564 ..>, :timestamp=>1304488440 } 
+  nibbler.parse("904040", :timestamp => Time.now.to_i)
+  # { :messages=> #<MIDIMessage::NoteOn:0x92f4564 ..>, :timestamp=>1304488440 }
+  
+Bind events
+
+  nibbler.when({ :class => MIDIMessage::NoteOn }) { puts "bark" }
+  nibbler.parse("904040")
+  
+  "bark"
+  #<MIDIMessage::NoteOn:0x98c9818 ...>
   
 Nibbler defaults to generate {midi-message}[http://github.com/arirusso/midi-message] objects, but it is also possible to use {midilib}[https://github.com/jimm/midilib] 
 
   Nibbler.new(:message_lib => :midilib)
   
-  p nibbler.parse("9", "0", 0x40, "40")
+  nibbler.parse("9", "0", 0x40, "40")
   "0: ch 00 on 40 40"
 
 == Author

data/lib/nibbler/nibbler.rb

@@ -7,7 +7,8 @@ module Nibbler
 
     extend Forwardable
 
-    attr_reader :messages,
+    attr_reader :callbacks,
+                :messages,
                 :processed,
                 :rejected
     
@@ -20,7 +21,8 @@ module Nibbler
     def_delegator :clear_messages, :messages, :clear
 
     def initialize(options = {}, &block)
-      @processed, @rejected, @messages = [], [], []
+      @timestamps = options[:timestamps] || false
+      @callbacks, @processed, @rejected, @messages = [], [], [], []
       @parser = Parser.new(options)    
       @typefilter = HexCharArrayFilter.new
       block.call unless block.nil?
@@ -30,9 +32,10 @@ module Nibbler
       @messages | @fragmented_messages
     end
     
-    def buffer_hex
+    def buffer_s
       buffer.join
     end
+    alias_method :buffer_hex, :buffer_s
 
     def clear_buffer
       buffer.clear
@@ -41,24 +44,69 @@ module Nibbler
     def clear_messages
       @messages.clear
     end
+    
+    def use_timestamps
+      @messages = @messages.map do |m|
+        { :messages => m, :timestamp => nil }
+      end
+      @timestamps = true
+    end
 
     def parse(*a)
-      options = a.last.kind_of?(Hash) ? a.pop : nil 
+      a.compact!
+      options = a.last.kind_of?(Hash) ? a.pop : nil      
+      timestamp = options[:timestamp] if !options.nil? && !options[:timestamp].nil?
+      use_timestamps if !timestamp.nil? && !@timestamps         
       queue = @typefilter.process(a)
       result = @parser.process(queue)
-      @messages += result[:messages]
+      record_message(result[:messages], timestamp)
+      handle_events(result[:messages]) unless @callbacks.empty?
       @processed += result[:processed]
       @rejected += result[:rejected]
-      #@buffer = result[:remaining]
+      get_parse_output(result[:messages], options)
+    end
+    
+    def when(hash, &proc)
+      if proc.nil?
+        warn "callback must have proc"
+        return false
+      end
+      hash[:proc] = proc
+      @callbacks << hash
+      true
+    end
+    alias_method :sees, :when
+    
+    private
+    
+    def handle_events(messages)
+      @callbacks.each do |cb|
+        messages.each do |msg|
+          match = true
+          cb.each do |key, val| 
+            match = false if !key.eql?(:proc) && !msg.send(key).eql?(val)
+          end           
+          cb[:proc].call(msg) if match   
+        end
+      end
+    end
+    
+    def record_message(msg, timestamp = nil)
+      !@timestamps ? @messages += msg : @messages << { 
+        :messages => msg, 
+        :timestamp => timestamp 
+      }     
+    end
+    
+    def get_parse_output(messages, options = nil)
       # return type
       # 0 messages: nil
       # 1 message: the message
       # >1 message: an array of messages
-      # might make sense to make this an array no matter what...
-      output = result[:messages].length < 2 ? 
-        (result[:messages].empty? ? nil : result[:messages][0]) : result[:messages]
-      output = { :messages => output, :timestamp => options[:timestamp] } unless options.nil? || options[:timestamp].nil?
-      output
+      # might make sense to make this an array no matter what...iii dunnoo
+      output = messages.length < 2 ? (messages.empty? ? nil : messages[0]) : messages
+      output = { :messages => output, :timestamp => options[:timestamp] } if @timestamps && !options.nil?
+      output      
     end
     
   end

data/lib/nibbler.rb

@@ -16,7 +16,7 @@ require 'nibbler/hex_char_array_filter'
 #
 module Nibbler
   
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 
   # shortcut to Parser.new
   def self.new(*a, &block)

metadata

@@ -2,7 +2,7 @@
 name: midi-nibbler
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Ari Russo
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-04 00:00:00 -04:00
+date: 2011-05-16 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency