unimidi 0.3.5 → 0.4.4

data/test/helper.rb

@@ -1,37 +1,34 @@
 dir = File.dirname(File.expand_path(__FILE__))
 $LOAD_PATH.unshift dir + '/../lib'
 
-require 'test/unit'
-require 'unimidi'
+require "test/unit"
+require "mocha/test_unit"
+require "shoulda-context"
+require "unimidi"
 
 module UniMIDI
 
-  module TestHelper
-
-    TestSysex = !RUBY_PLATFORM.include?("java")
+  class TestDeviceHelper
 
-    def self.select_devices
-      $test_device ||= {}
-      { :input => UniMIDI::Input, :output => UniMIDI::Output }.each do |type, klass|
-        $test_device[type] = klass.gets
+    def self.setup
+      if @test_devices.nil?
+        @test_devices = {}
+        { :input => UniMIDI::Input, :output => UniMIDI::Output }.each do |type, klass|
+          @test_devices[type] = klass.gets
+        end
       end
-    end 
+    end
 
-    def platform_test(adapter, mod, device_class = nil, input_class = nil, output_class = nil)
-      device_class ||= mod::Device
-      input_class ||= mod::Input
-      output_class ||= mod::Output
-      assert_equal(adapter, UniMIDI::Platform.instance.interface)
-      assert_not_same(input_class, UniMIDI::Input)
-      assert_not_same(output_class, UniMIDI::Output)
-      assert_not_same(device_class, UniMIDI::Device)
-      assert_equal(input_class.first.name, UniMIDI::Input.first.name)
-      assert_equal(input_class.first.id, UniMIDI::Input.first.id)
-      assert_not_same(output_class.first, UniMIDI::Output.first)
-      assert_equal(output_class.first.name, UniMIDI::Output.first.name)
-      assert_equal(output_class.first.id, UniMIDI::Output.first.id)
+    def self.devices
+      @test_devices
     end
 
+  end
+
+  module TestHelper
+
+    TestSysex = !RUBY_PLATFORM.include?("java")
+
     def bytestrs_to_ints(arr)
       data = arr.map { |m| m[:data] }.join
       output = []
@@ -87,5 +84,3 @@ module UniMIDI
   end
 
 end
-
-UniMIDI::TestHelper.select_devices

data/test/input_test.rb

@@ -0,0 +1,46 @@
+require 'helper'
+
+class UniMIDI::InputBufferTest < UniMIDI::TestCase
+
+  context "Input" do
+
+    setup do
+      TestDeviceHelper.setup
+    end
+
+    context "#buffer" do
+
+      setup do
+        sleep(1) 
+        @messages = VariousMIDIMessages
+        @bytes = []
+      end
+
+      should "add received messages to the buffer" 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)
+              @bytes += msg 
+              sleep(0.5)
+              buffer = input.buffer.map { |m| m[:data] }.flatten
+              $>.puts "received: " + buffer.to_s
+              assert_equal(@bytes, buffer)
+
+            end
+
+            assert_equal(@bytes.length, input.buffer.map { |m| m[:data] }.flatten.length)
+
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/platform_test.rb

@@ -1,29 +1,47 @@
 require 'helper'
 
-class PlatformTest < UniMIDI::TestCase
-  
-  def test_jruby
-    if RUBY_PLATFORM.include?("java")
-      platform_test(MIDIJRubyAdapter, MIDIJRuby)
-    end
-  end
-    
-  def test_linux
-    if RUBY_PLATFORM.include?("linux")
-      platform_test(AlsaRawMIDIAdapter, AlsaRawMIDI)
-    end  
+class UniMIDI::PlatformTest < UniMIDI::TestCase
+
+  def platform_test(adapter, mod, device_class = nil, input_class = nil, output_class = nil)
+    device_class ||= mod::Device
+    input_class ||= mod::Input
+    output_class ||= mod::Output
+    assert_not_same(input_class, UniMIDI::Input)
+    assert_not_same(output_class, UniMIDI::Output)
+    assert_not_same(device_class, UniMIDI::Device)
+    assert_equal(input_class.first.name, UniMIDI::Input.first.name)
+    assert_equal(input_class.first.id, UniMIDI::Input.first.id)
+    assert_not_same(output_class.first, UniMIDI::Output.first)
+    assert_equal(output_class.first.name, UniMIDI::Output.first.name)
+    assert_equal(output_class.first.id, UniMIDI::Output.first.id)
   end
-  
-  def test_osx
-    if RUBY_PLATFORM.include?("darwin")
-      platform_test(CoreMIDIAdapter, CoreMIDI, CoreMIDI::Endpoint, CoreMIDI::Source, CoreMIDI::Destination)
+
+  context "Platform" do
+
+    should "recognize java" do
+      if RUBY_PLATFORM.include?("java")
+        platform_test(Adapter::MIDIJRuby, ::MIDIJRuby)
+      end
+    end
+
+    should "recognize linux" do
+      if RUBY_PLATFORM.include?("linux")
+        platform_test(Adapter::AlsaRawMIDI, ::AlsaRawMIDI)
+      end  
+    end
+
+    should "recognize osx" do
+      if RUBY_PLATFORM.include?("darwin")
+        platform_test(Adapter::CoreMIDI, ::CoreMIDI, ::CoreMIDI::Endpoint, ::CoreMIDI::Source, ::CoreMIDI::Destination)
+      end  
+    end
+
+    should "recognize windows" do
+      if RUBY_PLATFORM.include?("mingw")
+        platform_test(Adapter::MIDIWinMM, ::MIDIWinMM)
+      end
     end  
+
   end
-  
-  def test_windows
-    if RUBY_PLATFORM.include?("mingw")
-      platform_test(MIDIWinMMAdapter, MIDIWinMM)
-    end
-  end  
-  
+
 end

data/test/type_conversion_test.rb

@@ -1,10 +1,18 @@
 require 'helper'
 
-class TypeConversionTest < UniMIDI::TestCase
-  
-  def test_numeric_byte_array_to_hex_string
-    result = TypeConversion.numeric_byte_array_to_hex_string([0x90, 0x40, 0x40])
-    assert "904040", result
+class UniMIDI::TypeConversionTest < UniMIDI::TestCase
+
+  context "TypeConversion" do
+
+    context "#numeric_byte_array_to_hex_string" do
+
+      should "convert byte array to hex string" do
+        result = TypeConversion.numeric_byte_array_to_hex_string([0x90, 0x40, 0x40])
+        assert "904040", result
+      end
+
+    end
+
   end
-  
+
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: unimidi
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.4
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-26 00:00:00.000000000 Z
+date: 2014-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ffi-coremidi
+  name: alsa-rawmidi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: midi-jruby
+  name: ffi-coremidi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: alsa-rawmidi
+  name: midi-jruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -80,18 +80,23 @@ files:
 - lib/unimidi/adapter/ffi-coremidi.rb
 - lib/unimidi/adapter/midi-jruby.rb
 - lib/unimidi/adapter/midi-winmm.rb
-- lib/unimidi/congruous_api_adapter.rb
+- lib/unimidi/command.rb
+- lib/unimidi/device.rb
+- lib/unimidi/input.rb
+- lib/unimidi/loader.rb
+- lib/unimidi/output.rb
 - lib/unimidi/platform.rb
 - lib/unimidi/type_conversion.rb
-- test/congruous_api_adapter_test.rb
+- test/adapter_test.rb
+- test/class_methods_test.rb
+- test/functional_test.rb
 - test/helper.rb
-- test/input_buffer_test.rb
-- test/io_test.rb
+- test/input_test.rb
 - test/platform_test.rb
-- test/selectors_test.rb
 - test/type_conversion_test.rb
 homepage: http://github.com/arirusso/unimidi
-licenses: []
+licenses:
+- Apache 2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []

data/lib/unimidi/congruous_api_adapter.rb

@@ -1,321 +0,0 @@
-module UniMIDI
-
-  module CongruousApiAdapter
-
-    module Device
-      
-      def initialize(device_obj)        
-        @device = device_obj
-        @id = @device.id
-        @name = @device.name
-        populate_type
-      end
-      
-      def enabled?
-        @device.enabled
-      end
-
-      # enable the device for use, can be passed a block to which the device will be passed back
-      def open(*a, &block)
-        @device.open(*a) unless enabled?
-        if block_given?
-          begin
-            yield(self)
-          ensure
-            close
-          end
-        else
-          at_exit do
-            close
-          end
-          self
-        end
-      end
-      
-      def pretty_name
-        "#{id}) #{name}"
-      end
-
-      # close the device
-      def close(*a)
-        @device.close(*a)
-      end
-
-      def self.included(base)
-        base.send(:attr_reader, :name)
-        base.send(:attr_reader, :id)
-        base.send(:attr_reader, :type)
-        base.send(:alias_method, :direction, :type)
-      end
-
-      module ClassMethods
-
-        include Enumerable
-
-        def each(&block)
-          all.each { |device| yield(device) }
-        end
-
-        # Prints ids and names of each device to the console
-        def list
-          all.each { |device| puts(device.pretty_name) }
-        end
-
-        # Shortcut to get a device by its name
-        def find_by_name(name)
-          all.find { |device| name == device.name }
-        end
-
-        # streamlined console prompt that asks the user to select a device
-        def gets(&block)
-          device = nil
-          class_name = self.name.split("::").last.downcase
-          puts ""
-          puts "Select a MIDI #{class_name}..."
-          while device.nil?
-            list
-            print "> "
-            selection = $stdin.gets.chomp
-            if selection != ""
-              selection = Integer(selection) rescue nil
-              device = all.find { |d| d.id == selection }
-            end
-          end
-          device.open(&block)
-        end
-        
-        # returns the first device for this class
-        def first(&block)
-          use_device(all.first, &block)
-        end
-
-        # returns the last device for this class
-        def last(&block)
-          use_device(all.last, &block)
-        end
-
-        # returns all devices in an array
-        def all
-          all_by_type.values.flatten
-        end
-        
-        # returns the device at <em>index</em> and opens it
-        def use(index, &block)
-          index = case index
-            when :first then 0
-            when :last then all.size - 1
-            else index
-          end
-          use_device(all[index], &block) 
-        end
-        alias_method :open, :use
-        
-        # returns the device at <em>index</em>
-        def [](index)
-          all[index]
-        end
-
-        # returns all devices as a hash as such
-        #   { :input => [input devices], :output => [output devices] }
-        def all_by_type
-          ensure_initialized
-          @devices
-        end
-
-        def defer_to(klass)
-          @deference ||= {}
-          @deference[self] = klass
-        end
-        
-        def device_class(klass)
-          @device_class = klass
-        end
-
-        def input_class(klass)
-          @input_class = klass
-        end
-
-        def output_class(klass)
-          @output_class = klass
-        end
-        
-        def populate
-          klass = @deference[self].respond_to?(:all_by_type) ? @deference[self] : @device_class
-          @devices = {
-            :input => klass.all_by_type[:input].map { |d| @input_class.new(d) },
-            :output => klass.all_by_type[:output].map { |d| @output_class.new(d) }
-          }          
-        end
-        alias_method :refresh, :populate
-        
-        private
-        
-        def ensure_initialized
-          populate unless initialized?
-        end
-
-        def initialized?
-          instance_variable_defined?(:@devices) && !@devices.nil?
-        end
-        
-        def use_device(device, &block)
-          device.open(&block)
-          device         
-        end
-
-      end
-      
-      private
-      
-      def populate_type
-        @type = case @device.type
-          when :source, :input then :input
-          when :destination, :output then :output
-        end
-      end
-
-    end
-
-  end
-
-  class CongruousApiInput
-    
-    include CongruousApiAdapter::Device
-    extend CongruousApiAdapter::Device::ClassMethods
-    extend Forwardable
-    
-    def_delegators :@device, :buffer
-    
-    #
-    # returns an 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 }
-    #   ]
-    #
-    # the data is an array of Numeric bytes
-    # the timestamp is the number of millis since this input was enabled
-    #
-    def gets(*a)
-      @device.gets(*a)
-    rescue SystemExit, Interrupt
-      exit
-    end
-
-    #
-    # same as gets but returns message data as string of hex digits as such:
-    #   [
-    #     { :data => "904060", :timestamp => 904 },
-    #     { :data => "804060", :timestamp => 1150 },
-    #     { :data => "90447F", :timestamp => 1300 }
-    #   ]
-    #
-    def gets_s(*a)
-      @device.gets_s(*a)
-    rescue SystemExit, Interrupt
-      exit
-    end
-    alias_method :gets_bytestr, :gets_s
-    alias_method :gets_hex, :gets_s
-
-    #
-    # returns an array of data bytes such as
-    #   [144, 60, 100, 128, 60, 100, 144, 40, 120]
-    #
-    def gets_data(*a)
-      arr = gets
-      arr.map { |msg| msg[:data] }.inject(:+)
-    end
-
-    #
-    # returns a string of data such as
-    #   "90406080406090447F"
-    #
-    def gets_data_s(*a)
-      arr = gets_bytestr
-      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 buffer
-    def clear_buffer
-      @device.buffer.clear
-    end
-    
-    # gets any messages in the buffer in the same format as CongruousApiInput#gets 
-    def gets_buffer(*a)
-      @device.buffer
-    end
-    
-    # gets any messages in the buffer in the same format as CongruousApiInput#gets_s
-    def gets_buffer_s(*a)
-      @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 CongruousApiInput#gets_data
-    def gets_buffer_data(*a)
-      @device.buffer.map { |msg| msg[:data] }
-    end
-
-    # returns all inputs
-    def self.all
-      UniMIDI::Device.all_by_type[:input]
-    end
-
-  end
-
-  class CongruousApiOutput
-    
-    include CongruousApiAdapter::Device
-    extend CongruousApiAdapter::Device::ClassMethods
-    
-    # sends a message to the output. the message can be:
-    #
-    # bytes eg output.puts(0x90, 0x40, 0x40)
-    # an array of bytes eg output.puts([0x90, 0x40, 0x40])
-    # or a string eg output.puts("904040")
-    # if none of those types are found, unimidi will attempt 
-    # to call to_bytes and then to_a on the object
-    #
-    def puts(*a)
-      case a.first
-        when Array then puts_bytes(*a.first)
-        when Numeric then puts_bytes(*a)
-        when String then puts_s(*a)
-        else
-          if a.first.respond_to?(:to_bytes)
-            puts_bytes(*a.first.to_bytes.flatten)
-          elsif a.first.respond_to?(:to_a) 
-            puts_bytes(*a.first.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 and therefore is more performant than puts
-    def puts_s(*a)
-      @device.puts_s(*a)
-    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 and therefore is more performant than puts
-    def puts_bytes(*a)
-      @device.puts_bytes(*a)
-    end
-
-    # returns all outputs
-    def self.all
-      UniMIDI::Device.all_by_type[:output]
-    end
-
-  end
-
-  class CongruousApiDevice
-    extend CongruousApiAdapter::Device::ClassMethods
-  end
-
-end