midi-eye 0.2.2 → 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2944fec81520048f22479d8fa72484928e3dcf65
+  data.tar.gz: bcab4013133af07447f36d6731e8840e9023b0d2
+SHA512:
+  metadata.gz: 4b91db15538087d57aa6ab1d7fd250f69ff5f09d12ebfd5c7200813fc6e6db38815d45563cc5d5c5b50ddf7a22ce3b6b17990b398c255f19b53eaa9fce270ccb
+  data.tar.gz: 1c4f0fa96f717e7f179ad4fbdf9608d8ccb76e17d30d08f96d4a75590a7e2f409ff8d29598424bcc853dd17983f570c67aecc979d248f763c89190f38b9bb994

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 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,83 @@
+# MIDI EYE
+
+MIDI input event listener for Ruby 
+
+## Install
+
+`gem install midi-eye`
+  
+or using Bundler, add this to your Gemfile
+
+`gem "midi-eye"`
+	
+## Usage
+
+```ruby
+require 'midi-eye'
+```
+
+The following is an example that takes any note messages received from a unimidi input, transposes them up one octave and then sends them to an output  
+  
+First, pick some MIDI IO ports
+
+```ruby 
+@input = UniMIDI::Input.gets
+@output = UniMIDI::Output.gets
+```
+
+Then create a listener for the input port
+
+```ruby 
+transpose = MIDIEye::Listener.new(@input)
+```
+
+You can bind an event to the listener using `Listener#listen_for`
+
+The listener will try to positively match the parameters you pass in to the properties of the messages it receives.
+
+In this example, we specify that the listener listens for note on/off messages, which are identifiable by their class.
+
+```ruby
+transpose.listen_for(:class => [MIDIMessage::NoteOn, MIDIMessage::NoteOff]) do |event|
+   
+  # raise the note value by an octave
+  event[:message].note += 12
+    
+  # send the altered note message to the output you chose earlier 
+  @output.puts(event[:message])
+  
+end
+```
+
+There is also the option of leaving out the parameters altogether and including using conditional if/unless/case/etc statements in the callback.
+  
+You can bind as many events to a listener as you wish by repeatedly calling `Listener#listen_for`
+
+Once all the events are bound, start the listener
+
+```ruby    
+transpose.run
+```
+
+A listener can also be run in a background thread by passing in `:background => true`.
+
+```ruby
+transpose.run(:background => true)
+  
+transpose.join # join the background thread later
+```
+
+## Documentation
+
+* [examples](http://github.com/arirusso/midi-eye/tree/master/examples)
+* [rdoc](http://rdoc.info/gems/midi-eye)
+    
+## 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-eye/listener.rb

@@ -1,65 +1,69 @@
-#!/usr/bin/env ruby
 module MIDIEye
   
   class Listener
     
     attr_reader :events 
     attr_accessor :sources
-      
-    @input_types = []
-      
-    class << self
-      # a registry of input types
-      attr_reader :input_types      
-    end
         
-    def initialize(input, options = {})
+    # @param [Array<UniMIDI::Input>, UniMIDI::Input] inputs Input(s) to add to the list of sources for this listener
+    def initialize(inputs)
       @sources = []
       @event_queue = []
       @events = []
   
-      add_input(input)
+      add_input(inputs)
     end
     
-    # does this listener use <em>input</em>?
+    # Does this listener use the given input?
+    # @param [UniMIDI::Input] input
+    # @return [Boolean]
     def uses_input?(input)
-      !@sources.find_all { |source| source.uses?(input) }.empty?
+      @sources.any? { |source| source.uses?(input) }
     end
     
-    # add a source
-    # takes a raw input or array of
-    def add_input(input)
-      @sources += [input].flatten.map do |i|
-        klass = self.class.input_types.find { |type| type.is_compatible?(i) }
-        raise "Input class type #{i.class.name} not compatible" if klass.nil?
-        klass.new(i) unless uses_input?(i)
-      end.compact
+    # Add a MIDI source
+    # @param [Array<UniMIDI::Input>, UniMIDI::Input] inputs Input(s) to add to the list of sources for this listener
+    # @return [Array<MIDIEye::Source>] The updated list of sources for this listener
+    def add_input(inputs)
+      inputs = [inputs].flatten.compact
+      new_sources = inputs.map do |input|
+        Source.new(input) unless uses_input?(input)
+      end
+      @sources += new_sources.compact
+      @sources
     end
+    alias_method :add_inputs, :add_input
     
-    # remove a source
-    # takes a raw input or array of
+    # Remove a MIDI source
+    # @param [Array<UniMIDI::Input>, UniMIDI::Input] inputs Input(s) to remove from the list of sources for this listener
+    # @return [Array<MIDIEye::Source>] The updated list of sources for this listener
     def remove_input(inputs)
-      to_remove = [inputs].flatten
-      to_remove.each do |input|
+      inputs = [inputs].flatten.compact
+      inputs.each do |input|
         @sources.delete_if { |source| source.uses?(input) }
       end
+      @sources
     end
-    
+    alias_method :remove_inputs, :remove_input
+   
+    # @param [Symbol] name
     def delete_event(name)
-      @events.delete_if { |e| e[:listener_name] == name }
+      @events.delete_if { |event| event[:listener_name] == name }
     end
     
-    # start the listener. pass in :background => true to run only in a background thread. returns self
+    # Start listening for MIDI messages
+    # @params [Hash] options
+    # @option options [Boolean] :background Run in a background thread
+    # @return [MIDIEye::Listener] self
     def run(options = {})      
-      listen!
-      unless options[:background]
-        @listener.join  
-      end
+      listen
+      join unless !!options[:background]
       self
     end
     alias_method :start, :run
     
-    # stop the listener. returns self
+    # Stop listening for MIDI messages.
+    # @return [MIDIEye::Listener] self
     def close
       @listener.kill unless @listener.nil?
       @events.clear
@@ -69,31 +73,45 @@ module MIDIEye
     end
     alias_method :stop, :close
     
-    # join the listener if it's being run in the background. returns self
+    # Join the listener if it's being run in the background.
+    # @return [MIDIEye::Listener] self
     def join
-      @listener.join
+      begin
+        @listener.join
+      rescue SystemExit, Interrupt
+        @listener.kill
+        raise
+      end
       self
     end
     
-    # add an event to listen for. returns self
-    def listen_for(options = {}, &proc)
-      raise 'listener must have a block' if proc.nil?
+    # Add an event to listen for
+    # @param [Hash] options
+    # @return [MIDIEye::Listener] self
+    def listen_for(options = {}, &callback)
+      raise "Listener must have a block" if callback.nil?
       name = options[:listener_name]
       options.delete(:listener_name)
-      @events << { :conditions => options, :proc => proc, :listener_name => name }
+      event = { 
+        :conditions => options, 
+        :proc => callback, 
+        :listener_name => name 
+      }
+      @events << event
       self      
     end
     alias_method :on_message, :listen_for
     alias_method :listen, :listen_for
     
-    # poll the input source for new input. this will normally be done by the background thread 
+    # Poll the input source for new input. This will normally be done by the background thread 
     def poll
       @sources.each do |input|
         input.poll do |objs|
           objs.each do |batch|
-            [batch[:messages]].flatten.each do |single_message|
-              unless single_message.nil?
-                data = { :message => single_message, :timestamp => batch[:timestamp] }
+            messages = [batch[:messages]].flatten.compact
+            messages.each do |message|
+              unless message.nil?
+                data = { :message => message, :timestamp => batch[:timestamp] }
                 @events.each { |name| queue_event(name, data) }
               end
             end 
@@ -103,48 +121,67 @@ module MIDIEye
     end
 
     private
-    
-    # start the background listener thread    
-    def listen!   
-      t = 1.0/1000
-      @listener = Thread.fork do       
-        Thread.abort_on_exception = true
-        loop do
-          poll
-          trigger_queued_events unless @event_queue.empty?
-          sleep(t)
-        end
+
+    # A loop that runs while the listener is active
+    def listen_loop
+      interval = 1.0/1000
+      loop do
+        poll
+        trigger_queued_events unless @event_queue.empty?
+        sleep(interval)
       end
     end
     
-    # trigger all queued events
+    # Start the background listener thread    
+    def listen
+      @listener = Thread.new { listen_loop }       
+      @listener.abort_on_exception = true
+      true
+    end
+    
+    # Trigger all queued events
     def trigger_queued_events
       @event_queue.length.times { trigger_event(@event_queue.shift) }
     end
     
-    # does <em>message</em> meet <em>conditions</em>?
+    # Does the given message meet the given conditions?
     def meets_conditions?(conditions, message)
-      !conditions.map do |key, value|
-        message.respond_to?(key) && (value.kind_of?(Array) ? value.include?(message.send(key)) : value.eql?(message.send(key))) 
-      end.include?(false)
+      results = conditions.map do |key, value|
+        if message.respond_to?(key)
+          if value.kind_of?(Array)
+            value.include?(message.send(key))
+          else
+            value.eql?(message.send(key))
+          end
+        else
+          false
+        end
+      end
+      results.all?
     end
     
-    # trigger an event
+    # Trigger an event
     def trigger_event(event)
-      begin
-        action = event[:action]
-        if meets_conditions?(action[:conditions], event[:message][:message]) || action[:conditions].nil?
+      action = event[:action]
+      conditions = action[:conditions]
+      if conditions.nil? || meets_conditions?(conditions, event[:message][:message])
+        begin
           action[:proc].call(event[:message])
+        rescue
+          # help
         end
-      rescue
       end
     end
     
-    # add an event to the trigger queue 
-    def queue_event(event, message)  
-      @event_queue << { :action => event, :message => message }
+    # Add an event to the trigger queue 
+    def queue_event(action, message)  
+      event = { 
+        :action => action, 
+        :message => message 
+      }
+      @event_queue << event
     end
                 
   end  
   
-end
+end

data/lib/midi-eye/source.rb

@@ -0,0 +1,44 @@
+module MIDIEye
+  
+  # Retrieves new messages from a unimidi input buffer
+  class Source
+    
+    attr_reader :device, :pointer
+    
+    # @param [UniMIDI::Input] input
+    def initialize(input)   
+      @parser = Nibbler.new
+      @pointer = 0
+      @device = input
+    end
+    
+    # Grabs new messages from the input buffer
+    def poll(&block)
+      messages = @device.buffer.slice(@pointer, @device.buffer.length - @pointer)
+      @pointer = @device.buffer.length
+      messages.each do |raw_message| 
+        unless raw_message.nil?
+          parsed_messages = @parser.parse(raw_message[:data], :timestamp => raw_message[:timestamp]) rescue nil
+          objects = [parsed_messages].flatten.compact
+          yield(objects)
+        end
+      end    
+    end
+    
+    # Whether the given object is a UniMIDI input
+    # @param [Object] input
+    # @return [Boolean]
+    def self.compatible?(input)
+      input.respond_to?(:gets) && input.respond_to?(:buffer)
+    end
+    
+    # If this source was created from the given input
+    # @param [UniMIDI::Input] input
+    # @return [Boolean]
+    def uses?(input)
+      @device == input
+    end
+        
+  end
+            
+end

data/lib/midi-eye.rb

@@ -1,20 +1,22 @@
-#!/usr/bin/env ruby
 #
 # midi-eye
-# Transparent MIDI event listener for Ruby
-# (c)2011 Ari Russo 
-# licensed under the Apache 2.0 License
+#
+# MIDI input event listener for Ruby
+# (c)2011-2014 Ari Russo 
+# Licensed under the Apache 2.0 License
 # 
 
+# libs
 require 'midi-message'
 require 'nibbler'
 require 'unimidi'
 
+# classes
 require 'midi-eye/listener'
-require 'midi-eye/unimidi_input'
+require 'midi-eye/source'
 
 module MIDIEye
   
-  VERSION = "0.2.2"
+  VERSION = "0.3.1"
   
-end
+end

data/test/{test_listener.rb → listener_test.rb}

@@ -1,6 +1,4 @@
-#!/usr/bin/env ruby
-
-require 'helper'
+require "helper"
 
 class ListenerTest < Test::Unit::TestCase
 
@@ -98,7 +96,7 @@ class ListenerTest < Test::Unit::TestCase
     input = $test_device[:input]
     output = $test_device[:output]
     listener = Listener.new(input)
-    assert_equal(UniMIDIInput, listener.sources.first.class)
+    assert_equal(Source, listener.sources.first.class)
     close_all(input, output, listener)
   end
   
@@ -153,4 +151,4 @@ class ListenerTest < Test::Unit::TestCase
     listener.join
   end
   
-end
+end

metadata

@@ -1,85 +1,93 @@
 --- !ruby/object:Gem::Specification
 name: midi-eye
 version: !ruby/object:Gem::Version
-  version: 0.2.2
-  prerelease: 
+  version: 0.3.1
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-05 00:00:00.000000000Z
+date: 2014-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: midi-message
-  requirement: &70223965375620 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70223965375620
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: midi-nibbler
-  requirement: &70223965375080 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70223965375080
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: unimidi
-  requirement: &70223965374640 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70223965374640
-description: MIDI event listener for Ruby
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A utility for dealing with MIDI input in Ruby.
 email:
 - ari.russo@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/midi-eye/listener.rb
-- lib/midi-eye/unimidi_input.rb
+- LICENSE
+- README.md
 - lib/midi-eye.rb
+- lib/midi-eye/listener.rb
+- lib/midi-eye/source.rb
 - test/helper.rb
-- test/test_listener.rb
-- LICENSE
-- README.rdoc
+- test/listener_test.rb
 homepage: http://github.com/arirusso/midi-eye
-licenses: []
+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
 requirements: []
 rubyforge_project: midi-eye
-rubygems_version: 1.8.6
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: MIDI event listener for Ruby
 test_files: []

data/README.rdoc

@@ -1,73 +0,0 @@
-= midi-eye
-
-A transparent MIDI input event listener for Ruby 
-
-== Requirements
-
-* {midi-message}[http://github.com/arirusso/midi-message]
-* {nibbler}[http://github.com/arirusso/nibbler]
-* {unimidi}[http://github.com/arirusso/unimidi]
-
-== Install
-
-  gem install midi-eye
-	
-== Usage
-
-  require 'midi-eye'
-
-The following is an example that takes any note messages received from a unimidi input, transposes them up one octave and then sends them to an output  
-  
-First, initialize the MIDI IO ports
-  
-  @input = UniMIDI::Input.gets
-  @output = UniMIDI::Output.gets
-  
-Then create a listener for the input port
- 
-  transpose = MIDIEye::Listener.new(@input)
-
-You can bind an event to the listener using Listener#listen_for
-
-The listener will try to positively match the parameters you pass in to the properties of the messages it receives.
-
-In this example, we will tell the listener to listen for note on/off messages which are easily identifiable by their class
-
-You also have the option of leaving out the parameters altogether and including using conditional if/unless/case/etc statements in your callback
-
-  transpose.listen_for(:class => [MIDIMessage::NoteOn, MIDIMessage::NoteOff]) do |event|
-   
-    # raise the note value by an octave
-    event[:message].note += 12
-    
-    # send the altered note message to the output you chose earlier 
-    @output.puts(event[:message])
-  
-  end
-  
-You can bind as many events to a listener as you wish, just keep calling Listener#listen_for
-
-Once all the events are bound, start the listener
-    
-  transpose.run
-   
-A listener can also be run in a background thread by passing in :background => true.
-
-  transpose.run(:background => true)
-  
-  transpose.join # join the background thread later
-
-== Documentation
-
-* {examples}[http://github.com/arirusso/midi-eye/tree/master/examples]
-* {rdoc}[http://rdoc.info/gems/midi-eye]
-    
-== 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

data/lib/midi-eye/unimidi_input.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-#
-module MIDIEye
-  
-  # this class deals with retrieving new messages from
-  # a unimidi input buffer
-  class UniMIDIInput
-    
-    attr_reader :device, :pointer
-    
-    def initialize(input)   
-      @parser = Nibbler.new   
-      @pointer = 0      
-      @device = input      
-    end
-    
-    # this grabs new messages from the unimidi buffer
-    def poll(&block)
-      msgs = @device.buffer.slice(@pointer, @device.buffer.length - @pointer)
-      @pointer = @device.buffer.length
-      msgs.each do |raw_msg| 
-        unless raw_msg.nil?      
-          objs = [@parser.parse(raw_msg[:data], :timestamp => raw_msg[:timestamp])].flatten.compact rescue []
-          yield(objs)
-        end
-      end    
-    end
-    
-    # if <em>input</em> looks like a unimidi input, this returns true
-    def self.is_compatible?(input)
-      input.respond_to?(:gets) && input.respond_to?(:buffer)
-    end
-    
-    # if this source was created from <em>input</em>
-    def uses?(input)
-      @device == input
-    end
-    
-    # add this class to the Listener class' known input types
-    Listener.input_types << self 
-    
-  end
-            
-end