unimidi 0.3.5 → 0.4.4

data/lib/unimidi/input.rb

@@ -0,0 +1,113 @@
+module UniMIDI
+
+  # A MIDI input device
+  class Input
+
+    extend Device::ClassMethods
+    include Device::InstanceMethods
+
+    # All MIDI input devices -- used to populate the class
+    # @return [Array<Input>]
+    def self.all
+      Loader.devices(:direction => :input)
+    end
+
+    # The device buffer
+    # @return [Array<Hash>]
+    def buffer
+      @device.buffer
+    end
+
+    #
+    # Plucks data from the input buffer and returns it as array of MIDI event hashes as such:
+    #   [
+    #     { :data => [144, 60, 100], :timestamp => 1024 },
+    #     { :data => [128, 60, 100], :timestamp => 1100 },
+    #     { :data => [144, 40, 120], :timestamp => 1200 }
+    #   ]
+    #
+    # In this case, the data is an array of Numeric bytes
+    # The timestamp is the number of millis since this input was enabled
+    # Arguments are passed to the underlying device object
+    #
+    # @param [*Object] args
+    # @return [Array<Hash>]
+    def gets(*args)
+      @device.gets(*args)
+    rescue SystemExit, Interrupt
+      exit
+    end
+
+    #
+    # Plucks data from the input buffer and returns it as array of MIDI event hashes.
+    # Similar to Input#gets except that the returned message data as string of hex digits eg:
+    #   [
+    #     { :data => "904060", :timestamp => 904 },
+    #     { :data => "804060", :timestamp => 1150 },
+    #     { :data => "90447F", :timestamp => 1300 }
+    #   ]
+    #
+    # @param [*Object] args
+    # @return [Array<Hash>]
+    def gets_s(*args)
+      @device.gets_s(*args)
+    rescue SystemExit, Interrupt
+      exit
+    end
+    alias_method :gets_bytestr, :gets_s
+    alias_method :gets_hex, :gets_s
+
+    #
+    # Plucks data from the input buffer and returns it as an array of data bytes such as
+    #   [144, 60, 100, 128, 60, 100, 144, 40, 120]
+    #
+    # @param [*Object] args
+    # @return [Array<Fixnum>]
+    def gets_data(*args)
+      arr = gets(*args)
+      arr.map { |msg| msg[:data] }.inject(:+)
+    end
+
+    #
+    # Plucks data from the input buffer and returns it as a string of data such as
+    #   "90406080406090447F"
+    #
+    # @param [*Object] args
+    # @return [String]
+    def gets_data_s(*args)
+      arr = gets_bytestr(*args)
+      arr.map { |msg| msg[:data] }.join
+    end
+    alias_method :gets_data_bytestr, :gets_data_s
+    alias_method :gets_data_hex, :gets_data_s
+
+    # Clears the input buffer
+    # @return [Array]
+    def clear_buffer
+      @device.buffer.clear
+    end
+
+    # Gets any messages in the buffer in the same format as Input#gets, without removing them from the buffer
+    # @param [*Object] args
+    # @return [Array<Hash>]
+    def gets_buffer(*args)
+      @device.buffer
+    end
+
+    # Gets any messages in the buffer in the same format as Input#gets_s, without removing them from the buffer
+    # @param [*Object] args
+    # @return [Array<Hash>]
+    def gets_buffer_s(*args)
+      @device.buffer.map { |msg| msg[:data] = TypeConversion.numeric_byte_array_to_hex_string(msg[:data]); msg }
+    end
+
+    # Gets any messages in the buffer in the same format as Input#gets_data without removing them from the buffer
+    # @param [*Object] args
+    # @return [Array<Fixnum>]
+    def gets_buffer_data(*args)
+      @device.buffer.map { |msg| msg[:data] }
+    end
+
+  end
+
+end

data/lib/unimidi/loader.rb

@@ -0,0 +1,30 @@
+module UniMIDI
+
+  # Populate UniMIDI devices using the underlying device objects from the platform-specific gems
+  module Loader
+
+    extend self
+
+    # Use the given platform-specific adapter to load devices
+    # @param [UniMIDI::Adapter::Loader] loader
+    def use(loader)
+      @loader = loader
+    end
+
+    # @param [Hash] options
+    # @option options [Symbol] :direction Return only a particular direction of device eg :input, :output
+    # @return [Array<Input>, Array<Output>]
+    def devices(options = {})
+      if @devices.nil?
+        inputs = @loader.inputs.map { |device| ::UniMIDI::Input.new(device) }
+        outputs = @loader.outputs.map { |device| ::UniMIDI::Output.new(device) }
+        @devices = {
+          :input => inputs,
+          :output => outputs
+        }
+      end
+      options[:direction].nil? ? @devices.values.flatten : @devices[options[:direction]]
+    end
+
+  end
+end

data/lib/unimidi/output.rb

@@ -0,0 +1,63 @@
+module UniMIDI
+
+  # A MIDI output device
+  class Output
+
+    extend Device::ClassMethods
+    include Device::InstanceMethods
+
+    # All MIDI output devices -- used to populate the class
+    # @return [Array<Output>]
+    def self.all
+      Loader.devices(:direction => :output)
+    end
+
+    # Sends a message to the output. 
+    #
+    # The message format can be:
+    #
+    # 1. Numeric bytes eg output.puts(0x90, 0x40, 0x40)
+    # 2. An array of numeric bytes [0x90, 0x40, 0x40]
+    # 3. A string of bytes eg "904040"
+    # 4. An array of strings ["904040", "804040"]
+    #
+    # @param [*Array<Fixnum>, *Array<String>, *Fixnum, *String] messages
+    # @return [Array<Fixnum>, Array<String>]
+    def puts(*messages)
+      message = messages.first
+      case message
+      when Array then message.each { |message| puts(*message) }
+      when Fixnum then puts_bytes(*messages)
+      when String then puts_s(*messages)
+      else
+        if message.respond_to?(:to_bytes)
+          puts_bytes(*message.to_bytes.flatten)
+        elsif message.respond_to?(:to_a) 
+          puts_bytes(*message.to_a.flatten)
+        end
+      end
+    end
+
+    # Sends a message to the output in a form of a string eg "904040".  This method does not do
+    # type checking
+    # @param [*String] messages
+    # @return [Array<String>, Array<Array<String>>]
+    def puts_s(*messages)
+      @device.puts_s(*messages)
+      messages.count < 2 ? messages[0] : messages
+    end
+    alias_method :puts_bytestr, :puts_s
+    alias_method :puts_hex, :puts_s
+
+    # Sends a message to the output in a form of bytes eg output.puts_bytes(0x90, 0x40, 0x40).
+    # This method does not do type checking.
+    # @param [*Array<Fixnum>] messages
+    # @return [Array<Fixnum>, Array<Array<Fixnum>>]
+    def puts_bytes(*messages)
+      @device.puts_bytes(*messages)
+      messages.count < 2 ? messages[0] : messages
+    end
+
+  end
+
+end

data/lib/unimidi/platform.rb

@@ -1,12 +1,12 @@
 module UniMIDI
-  
-  class Platform
 
-    include Singleton
+  # Deal with different dependencies between different user environments
+  module Platform
 
-    attr_reader :interface
+    extend self
     
-    def initialize
+    # Loads the proper MIDI library and adapter for the user's environment
+    def bootstrap
       lib = case RUBY_PLATFORM
         when /darwin/ then "ffi-coremidi"
         when /java/ then "midi-jruby"
@@ -14,12 +14,13 @@ module UniMIDI
         when /mingw/ then "midi-winmm"
       end
       require("unimidi/adapter/#{lib}")
-      @interface = case RUBY_PLATFORM
-        when /darwin/ then CoreMIDIAdapter
-        when /java/ then MIDIJRubyAdapter
-        when /linux/ then AlsaRawMIDIAdapter
-        when /mingw/ then MIDIWinMMAdapter
+      interface = case RUBY_PLATFORM
+        when /darwin/ then Adapter::CoreMIDI
+        when /java/ then Adapter::MIDIJRuby
+        when /linux/ then Adapter::AlsaRawMIDI
+        when /mingw/ then Adapter::MIDIWinMM
       end
+      Loader.use(interface::Loader)
     end
 
   end

data/lib/unimidi/type_conversion.rb

@@ -1,6 +1,6 @@
 module UniMIDI
   
-  # Utility module for converting between different data formats
+  # Utility for converting between different data formats
   module TypeConversion
 
     extend self

data/test/adapter_test.rb

@@ -0,0 +1,70 @@
+require "helper"
+
+class UniMIDI::AdapterTest < UniMIDI::TestCase
+
+  context "Adapter" do
+
+    setup do
+      TestDeviceHelper.setup
+    end
+
+    context "Device#type" do
+
+      should "be an input" do
+        input = TestDeviceHelper.devices[:input]
+        assert_equal(:input, input.type)
+      end
+
+      should "be an output" do
+        output = TestDeviceHelper.devices[:output]
+        assert_equal(:output, output.type)  
+      end
+
+    end
+
+    context "Device.count" do
+
+      setup do
+        @inputs = Input.all
+      end
+
+      should "count all of the inputs" do
+        assert_equal @inputs.count, Input.count
+      end
+
+    end
+
+    context "Device.find_by_name" do
+
+      setup do
+        index = rand(0..(Output.count-1))
+        @output = Output.all[index]
+      end
+
+      should "select the correct input" do
+        result = Output.find_by_name(@output.name)
+        assert_equal @output, result
+      end
+
+    end
+
+    context "Device.first" do
+
+      setup do
+        @output = Output.all.first
+      end
+
+      should "open the output" do
+        @output.expects(:open)
+        output = Output.first
+        @output.unstub(:open)
+      end
+
+      should "return the correct output" do
+        output = Output.first
+        assert_equal @output, output
+      end
+    end
+
+  end
+end

data/test/class_methods_test.rb

@@ -0,0 +1,99 @@
+require "helper"
+
+class UniMIDI::ClassMethodsTest < UniMIDI::TestCase
+
+  context "ClassMethods" do
+
+    setup do
+      TestDeviceHelper.setup
+    end
+
+    context "#first" do
+
+      context "no block given" do
+        should "return first input" do
+          i = Input.first
+          assert_equal(Input.all.first, i)
+        end
+      end
+
+      context "block given" do
+        should "pass and return first input" do
+          sleep(1)
+          i = Input.first do |i|
+            assert_equal(true, i.enabled?)
+          end
+          assert_equal(Input.all.first, i)
+        end
+
+      end
+    end
+
+    context "#last" do
+
+      context "no block given" do
+        should "return last input" do
+          i = Input.last
+          assert_equal(Input.all.last, i)    
+        end
+      end
+
+      context "block given" do
+        should "pass and return last input" do
+          sleep(1)
+          i = Input.last do |i|
+            assert_equal(true, i.enabled?)     
+          end
+          assert_equal(Input.all.last, i)     
+        end
+
+      end
+    end
+
+    context "#[]" do
+
+      should "return correct input" do
+        i = Input[0]
+        assert_equal(Input.first, i)
+        assert_equal(Input.all.first, i)
+      end
+
+    end
+
+    context "#use" do
+
+      context "block given" do
+        should "return and enable an input" do
+          sleep(1)
+          i = Input.use(0) do |i|
+            assert_equal(true, i.enabled?) 
+          end
+          assert_equal(Input.first, i)
+          assert_equal(Input.all.first, i)    
+        end
+
+      end
+
+      context "with symbol" do
+
+        should "return an enabled input" do
+          sleep(1)
+          input = Input.use(:first)
+          assert_equal(true, input.enabled?) 
+          assert_equal(Input.first, input)
+          assert_equal(Input.all.first, input)       
+        end
+
+      end
+
+    end
+
+    context "#all" do
+      should "return all devices" do
+        assert_equal(Loader.devices(:direction => :input), Input.all)
+      end
+    end
+
+  end
+
+end

data/test/functional_test.rb

@@ -0,0 +1,128 @@
+require "helper"
+
+class UniMIDI::FunctionalTest < UniMIDI::TestCase
+
+  # ** these tests assume that TestOutput is connected to TestInput
+  context "UniMIDI" do
+
+    setup do
+      sleep(1)
+      TestDeviceHelper.setup
+    end
+
+    context "full IO" do
+
+      context "using Arrays" do
+
+        setup do
+          @messages = VariousMIDIMessages
+          @messages_arr = @messages.inject { |a,b| a+b }.flatten
+          @received_arr = []
+          @pointer = 0
+        end
+
+        should "do IO" do
+          TestDeviceHelper.devices[:output].open do |output|
+            TestDeviceHelper.devices[:input].open do |input|
+
+              input.buffer.clear
+
+              @messages.each do |msg|
+
+                $>.puts "sending: " + msg.inspect
+
+                output.puts(msg)
+                sleep(1)
+                received = input.gets.map { |m| m[:data] }.flatten
+
+                $>.puts "received: " + received.inspect
+
+                assert_equal(@messages_arr.slice(@pointer, received.length), received)
+                @pointer += received.length
+                @received_arr += received
+              end
+              assert_equal(@messages_arr.length, @received_arr.length)
+            end
+          end
+
+        end
+      end
+
+      context "using byte Strings" do
+
+        setup do
+          @messages = VariousMIDIByteStrMessages
+          @messages_str = @messages.join
+          @received_str = ""
+          @pointer = 0
+        end
+
+        should "do IO" do
+          TestDeviceHelper.devices[:output].open do |output|
+            TestDeviceHelper.devices[:input].open do |input|
+
+              @messages.each do |msg|
+
+                $>.puts "sending: " + msg.inspect
+
+                output.puts(msg)
+                sleep(1)
+                received = input.gets_bytestr.map { |m| m[:data] }.flatten.join
+                $>.puts "received: " + received.inspect
+
+                assert_equal(@messages_str.slice(@pointer, received.length), received)
+                @pointer += received.length
+                @received_str += received
+              end
+              assert_equal(@messages_str, @received_str)
+
+            end
+          end
+
+
+        end
+
+      end
+
+      context "using MIDIMessages" do
+
+        setup do
+          @messages = VariousMIDIObjects
+          @messages_arr = @messages.map { |m| m.to_bytes }.flatten
+          @received_arr = []
+          @pointer = 0
+        end
+
+        should "do IO" do
+          TestDeviceHelper.devices[:output].open do |output|
+            TestDeviceHelper.devices[:input].open do |input|
+
+              #input.buffer.clear
+
+              @messages.each do |msg|
+
+                $>.puts "sending: " + msg.inspect
+
+                output.puts(msg)
+                sleep(1)
+                received = input.gets.map { |m| m[:data] }.flatten
+
+                $>.puts "received: " + received.inspect
+
+                assert_equal(@messages_arr.slice(@pointer, received.length), received)
+                @pointer += received.length
+                @received_arr += received
+              end
+              assert_equal(@messages_arr.length, @received_arr.length)
+
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end