launchpad 0.2.0 → 0.2.1

data/README.rdoc

@@ -67,10 +67,16 @@ For more details, see the examples. examples/color_picker.rb is the most complex
 
 * interaction responses for presses on single grid buttons/button areas
 * bitmap rendering
+* internal tracking of LED states for both buffers
 
 
 == Changelog
 
+=== v.0.2.1
+
+* Launchpad::Interaction#close now properly stops interaction first
+* multi threading: Launchpad::Interaction#start method can be called with :detached => true to allow calling thread to continue
+
 === v.0.2.0
 
 * double buffering (see Launchpad::Device#buffering_mode)

data/Rakefile

@@ -14,7 +14,7 @@ begin
     gem.version = Launchpad::VERSION
     gem.authors = ['Thomas Jachmann']
     gem.has_rdoc = true
-    gem.add_dependency('portmidi')
+    gem.add_dependency('portmidi', '>= 0.0.6')
     gem.add_development_dependency('thoughtbot-shoulda', '>= 0')
     gem.add_development_dependency('mocha')
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings

data/examples/color_picker.rb

@@ -1,9 +1,6 @@
 require File.join(File.dirname(__FILE__), 'setup')
 
-# need to declare as instance variables here for being able to access
-# @interaction within interactors created by create_interactor_block
-device = Launchpad::Device.new
-interaction = Launchpad::Interaction.new(:device => device)
+interaction = Launchpad::Interaction.new
 
 # build color arrays for color display views
 colors_single = [

data/launchpad.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{launchpad}
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Thomas Jachmann"]
-  s.date = %q{2009-11-24}
+  s.date = %q{2010-01-24}
   s.description = %q{This gem provides an interface to access novation's launchpad programmatically. LEDs can be lighted and button presses can be evaluated using launchpad's MIDI input/output.}
   s.email = %q{tom.j@gmx.net}
   s.extra_rdoc_files = [
@@ -66,16 +66,16 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<portmidi>, [">= 0"])
+      s.add_runtime_dependency(%q<portmidi>, [">= 0.0.6"])
       s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
       s.add_development_dependency(%q<mocha>, [">= 0"])
     else
-      s.add_dependency(%q<portmidi>, [">= 0"])
+      s.add_dependency(%q<portmidi>, [">= 0.0.6"])
       s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
       s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
-    s.add_dependency(%q<portmidi>, [">= 0"])
+    s.add_dependency(%q<portmidi>, [">= 0.0.6"])
     s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
     s.add_dependency(%q<mocha>, [">= 0"])
   end

data/lib/launchpad.rb

@@ -1,4 +1,3 @@
-require 'launchpad/device'
 require 'launchpad/interaction'
 
 # All the fun of launchpad in one module!

data/lib/launchpad/device.rb

@@ -145,7 +145,10 @@ module Launchpad
     #           * Hash:
     #             [<tt>:red</tt>]   brightness of red LED
     #             [<tt>:green</tt>] brightness of green LED
-    #             [<tt>:mode</tt>]  button mode
+    #             [<tt>:mode</tt>]  button mode, defaults to <tt>:normal</tt>, one of:
+    #                               [<tt>:normal/tt>]     updates the LEDs for all circumstances (the new value will be written to both buffers)
+    #                               [<tt>:flashing/tt>]   updates the LEDs for flashing (the new values will be written to buffer 0 while the LEDs will be off in buffer 1, see buffering_mode)
+    #                               [<tt>:buffering/tt>]  updates the LEDs for the current update_buffer only
     #           the array consists of 64 colors for the grid buttons,
     #           8 colors for the scene buttons (top to bottom)
     #           and 8 colors for the top control buttons (left to right),

data/lib/launchpad/interaction.rb

@@ -53,7 +53,13 @@ module Launchpad
     end
     
     # Closes the interaction's device - nothing can be done with the interaction/device afterwards.
+    # 
+    # Errors raised:
+    # 
+    # [Launchpad::NoInputAllowedError] when input is not enabled on the interaction's device
+    # [Launchpad::CommunicationError] when anything unexpected happens while communicating with the    
     def close
+      stop
       @device.close
     end
     
@@ -62,27 +68,55 @@ module Launchpad
       @device.closed?
     end
     
-    # Starts interacting with the launchpad, blocking. Resets the device when
-    # the interaction was properly stopped via stop.
+    # Starts interacting with the launchpad. Resets the device when
+    # the interaction was properly stopped via stop or close.
+    # 
+    # Optional options hash:
+    # 
+    # [<tt>:detached</tt>]  <tt>true/false</tt>,
+    #                       whether to detach the interaction, method is blocking when +false+
+    #                       optional, defaults to +false+
     # 
     # Errors raised:
     # 
     # [Launchpad::NoInputAllowedError] when input is not enabled on the interaction's device
+    # [Launchpad::NoOutputAllowedError] when output is not enabled on the interaction's device
     # [Launchpad::CommunicationError] when anything unexpected happens while communicating with the launchpad
-    def start
+    def start(opts = nil)
+      opts = {
+        :detached => false
+      }.merge(opts || {})
       @active = true
-      while @active do
-        @device.read_pending_actions.each {|action| respond_to_action(action)}
-        sleep @latency unless @latency <= 0
+      @reader_thread ||= Thread.new do
+        begin
+          while @active do
+            @device.read_pending_actions.each {|action| respond_to_action(action)}
+            sleep @latency unless @latency <= 0
+          end
+        rescue Portmidi::DeviceError => e
+          raise CommunicationError.new(e)
+        ensure
+          @device.reset
+        end
       end
-      @device.reset
-    rescue Portmidi::DeviceError => e
-      raise CommunicationError.new(e)
+      @reader_thread.join unless opts[:detached]
     end
     
-    # Stops interacting with the launchpad and resets it.
+    # Stops interacting with the launchpad.
+    # 
+    # Errors raised:
+    # 
+    # [Launchpad::NoInputAllowedError] when input is not enabled on the interaction's device
+    # [Launchpad::CommunicationError] when anything unexpected happens while communicating with the    
     def stop
       @active = false
+      if @reader_thread
+        # run (resume from sleep) and wait for @reader_thread to end
+        @reader_thread.run if @reader_thread.alive?
+        @reader_thread.join
+        @reader_thread = nil
+      end
+      nil
     end
     
     # Registers a response to one or more actions.

data/lib/launchpad/version.rb

@@ -1,3 +1,3 @@
 module Launchpad
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/test/test_interaction.rb

@@ -16,6 +16,11 @@ class TestInteraction < Test::Unit::TestCase
       assert_equal 'device', Launchpad::Interaction.new(:device_name => 'device').device
     end
     
+    should 'create device with given input_device_id/output_device_id' do
+      Launchpad::Device.expects(:new).with(:input_device_id => 'in', :output_device_id => 'out', :input => true, :output => true).returns('device')
+      assert_equal 'device', Launchpad::Interaction.new(:input_device_id => 'in', :output_device_id => 'out').device
+    end
+    
     should 'initialize device if given' do
       assert_equal 'device', Launchpad::Interaction.new(:device => 'device').device
     end
@@ -28,18 +33,17 @@ class TestInteraction < Test::Unit::TestCase
   
   context 'close' do
     
-    should 'close device' do
-      interaction = Launchpad::Interaction.new(:device => device = Launchpad::Device.new)
-      device.expects(:close)
+    should 'not be active' do
+      interaction = Launchpad::Interaction.new
+      interaction.start(:detached => true)
       interaction.close
+      assert !interaction.active
     end
     
-    should 'craise NoInputAllowedError on subsequent accesses' do
+    should 'close device' do
       interaction = Launchpad::Interaction.new(:device => device = Launchpad::Device.new)
+      device.expects(:close)
       interaction.close
-      assert_raise Launchpad::NoInputAllowedError do
-        interaction.start
-      end
     end
     
   end
@@ -57,27 +61,45 @@ class TestInteraction < Test::Unit::TestCase
   
   context 'start' do
     
-    # this is kinda greybox tested, since I couldn't come up with another way to test a loop [thomas, 2009-11-11]
-    
     setup do
       @interaction = Launchpad::Interaction.new(:device => @device = Launchpad::Device.new)
     end
     
-    context 'up until read_pending_actions' do
-      
-      setup do
-        @device.stubs(:read_pending_actions).raises(BreakError)
-      end
-      
-      should 'set active to true' do
-        begin
-          @interaction.start
-          fail 'should raise BreakError'
-        rescue BreakError
-          assert @interaction.active
-        end
+    teardown do
+      begin
+        @interaction.close
+      rescue
+        # ignore, should be handled in tests, this is just to close all the spawned threads
       end
-      
+    end
+    
+    # this is kinda greybox tested, since I couldn't come up with another way to test thread handling [thomas, 2010-01-24]
+    should 'set active to true in blocking mode' do
+      t = Thread.new {}
+      Thread.expects(:new).returns(t)
+      @interaction.start
+      assert @interaction.active
+    end
+    
+    should 'set active to true in detached mode' do
+      @interaction.start(:detached => true)
+      assert @interaction.active
+    end
+    
+    # this is kinda greybox tested, since I couldn't come up with another way to test thread handling [thomas, 2010-01-24]
+    should 'start a new thread and block in blocking mode' do
+      t = Thread.new {}
+      Thread.expects(:new).returns(t)
+      t.expects(:join)
+      @interaction.start
+    end
+    
+    # this is kinda greybox tested, since I couldn't come up with another way to test thread handling [thomas, 2010-01-24]
+    should 'start a new thread and return in detached mode' do
+      t = Thread.new {}
+      Thread.expects(:new).returns(t)
+      t.expects(:join).never
+      @interaction.start(:detached => true)
     end
     
     should 'raise CommunicationError when Portmidi::DeviceError occurs' do
@@ -87,18 +109,16 @@ class TestInteraction < Test::Unit::TestCase
       end
     end
     
+    # this is kinda greybox tested, since I couldn't come up with another way to test thread handling [thomas, 2010-01-24]
     should 'call respond_to_action with actions from respond_to_action' do
-      begin
-        @interaction.stubs(:sleep).raises(BreakError)
-        @device.stubs(:read_pending_actions).returns(['message1', 'message2'])
-        @interaction.expects(:respond_to_action).with('message1').once
-        @interaction.expects(:respond_to_action).with('message2').once
-        @interaction.start
-        fail 'should raise BreakError'
-      rescue BreakError
-      end
+      @interaction.stubs(:sleep).raises(BreakError)
+      @device.stubs(:read_pending_actions).returns(['message1', 'message2'])
+      @interaction.expects(:respond_to_action).with('message1').once
+      @interaction.expects(:respond_to_action).with('message2').once
+      @interaction.start(:detached => true)
     end
     
+    # this is kinda greybox tested, since I couldn't come up with another way to test thread handling [thomas, 2010-01-24]
     context 'sleep' do
       
       setup do
@@ -106,52 +126,101 @@ class TestInteraction < Test::Unit::TestCase
       end
       
       should 'sleep with default latency of 0.001 when none given' do
-        begin
+        assert_raise BreakError do
           @interaction.expects(:sleep).with(0.001).raises(BreakError)
           @interaction.start
-          fail 'should raise BreakError'
-        rescue BreakError
         end
       end
       
       should 'sleep with given latency' do
-        begin
+        assert_raise BreakError do
           @interaction = Launchpad::Interaction.new(:latency => 4, :device => @device)
           @interaction.expects(:sleep).with(4).raises(BreakError)
           @interaction.start
-          fail 'should raise BreakError'
-        rescue BreakError
         end
       end
       
       should 'sleep with absolute value of given negative latency' do
-        begin
+        assert_raise BreakError do
           @interaction = Launchpad::Interaction.new(:latency => -3.1, :device => @device)
           @interaction.expects(:sleep).with(3.1).raises(BreakError)
           @interaction.start
-          fail 'should raise BreakError'
-        rescue BreakError
         end
       end
       
-      should 'not sleep when latency is <= 0' # TODO don't know how to test this [thomas, 2009-11-11]
+      should 'not sleep when latency is 0' do
+        @interaction = Launchpad::Interaction.new(:latency => 0, :device => @device)
+        @interaction.expects(:sleep).never
+        @interaction.start(:detached => true)
+      end
       
     end
     
-    should 'reset the device after the loop' # TODO don't know how to test this [thomas, 2009-11-11]
+    should 'reset the device after the loop' do
+      @interaction.device.expects(:reset)
+      @interaction.start(:detached => true)
+      @interaction.stop
+    end
+    
+    should 'raise NoOutputAllowedError on closed interaction' do
+      @interaction.close
+      assert_raise Launchpad::NoOutputAllowedError do
+        @interaction.start
+      end
+    end
     
   end
   
   context 'stop' do
     
-    should 'set active to false' do
+    should 'set active to false in blocking mode' do
+      i = Launchpad::Interaction.new
+      Thread.new do
+        i.start
+      end
+      assert i.active
+      i.stop
+      assert !i.active
+    end
+    
+    should 'set active to false in detached mode' do
       i = Launchpad::Interaction.new
-      i.instance_variable_set('@active', true)
+      i.start(:detached => true)
       assert i.active
       i.stop
       assert !i.active
     end
     
+    should 'be callable anytime' do
+      i = Launchpad::Interaction.new
+      i.stop
+      i.start(:detached => true)
+      i.stop
+      i.stop
+    end
+    
+    # this is kinda greybox tested, since I couldn't come up with another way to test thread handling [thomas, 2010-01-24]
+    should 'call run and join on a running reader thread' do
+      t = Thread.new {sleep}
+      Thread.expects(:new).returns(t)
+      t.expects(:run)
+      t.expects(:join)
+      i = Launchpad::Interaction.new
+      i.start(:detached => true)
+      i.stop
+    end
+    
+    # this is kinda greybox tested, since I couldn't come up with another way to test tread handling [thomas, 2010-01-24]
+    should 'raise pending exceptions in detached mode' do
+      t = Thread.new {raise BreakError}
+      Thread.expects(:new).returns(t)
+      i = Launchpad::Interaction.new
+      i.start(:detached => true)
+      assert_raise BreakError do
+        i.stop
+      end
+    end
+    
   end
   
   context 'response_to/no_response_to/respond_to' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: launchpad
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Thomas Jachmann
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-24 00:00:00 +01:00
+date: 2010-01-24 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.0.6
     version: 
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda