unimidi 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0531893dc83d0ed407f9c4f984c488058481957e
-  data.tar.gz: c22c25a2305d2007e7179cf8826268abb4e40156
+  metadata.gz: bf68a7b6957f53fe2ccdb7922af43d3ee59bcc8e
+  data.tar.gz: ad6dc382083631d6f8277e319d39af5e5bc27cad
 SHA512:
-  metadata.gz: 7abb6b93f5b49ec458ee47e24f277446528a233a174e6aed9c54db93239648d2ef058ef788f9532c24793c4b1b335a50ffa4ff10be360068d43bf49560a93586
-  data.tar.gz: 7372540218623430ed69eb8012e1d8493e52693923801dc6326a607ad16040c69033e7097d9e433aa347e1b089a8fa0c91ff045973616caad5078431b8e5a6d9
+  metadata.gz: 8386b3217cae71e3712d12644c2371b6fd9b6bbcf11fb3b1537a38773a4fc077da771ef3713e417bca1248d6a4f1f6ab605dbd505a5aa0a686377b60b8605b88
+  data.tar.gz: 630f39aa818ad71e336dca7597e14a8c5b9bdf1237e9d8839aede3e50f504b763aa60f1a7512426903163f3e270f43d785c246f1bff0950adf84d2f2508868c4

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2010-2016 Ari Russo
+Copyright 2010-2017 Ari Russo
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/README.md

@@ -84,4 +84,4 @@ See below for additional notes on testing with JRuby
 
 Apache 2.0, See the file LICENSE
 
-Copyright (c) 2010-2016 Ari Russo  
+Copyright (c) 2010-2017 Ari Russo  

data/lib/unimidi.rb

@@ -1,24 +1,25 @@
 #
+# UniMIDI
 # Realtime MIDI IO for Ruby
 #
-# (c)2010-2016 Ari Russo
+# (c)2010-2017 Ari Russo
 # Licensed under the Apache 2.0 License
 #
 
 # modules
 require "unimidi/command"
 require "unimidi/device"
-require "unimidi/loader"
 require "unimidi/platform"
 require "unimidi/type_conversion"
 
 # classes
 require "unimidi/input"
+require "unimidi/loader"
 require "unimidi/output"
 
 module UniMIDI
 
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 
   Platform.bootstrap
 

data/lib/unimidi/device.rb

@@ -63,38 +63,43 @@ module UniMIDI
       end
 
       # Select the device at the given index and enable it
-      # @param [Fixnum] index
+      # @param [Integer] index
       # @return [Input, Output]
       def use(index, &block)
         index = case index
                 when :first then 0
-                when :last then all.size - 1
+                when :last then all.count - 1
                 else index
                 end
-        use_device(all[index], &block)
+        use_device(at(index), &block)
       end
       alias_method :open, :use
 
       # Select the device at the given index
-      # @param [Fixnum] index
+      # @param [Integer] index
       # @return [Input, Output]
-      def [](index)
+      def at(index)
         all[index]
       end
+      alias_method :[], :at
 
       private
 
       # The direction of the device eg "input", "output"
       # @return [String]
       def get_direction
-        self.name.split("::").last.downcase
+        name.split("::").last.downcase
       end
 
       # Enable the given device
       # @param [Input, Output] device
       # @return [Input, Output]
       def use_device(device, &block)
-        device.open(&block) unless device.enabled?
+        if device.enabled?
+          yield(device) if block_given?
+        else
+          device.open(&block)
+        end
         device
       end
 
@@ -155,6 +160,12 @@ module UniMIDI
         end
       end
 
+      # Returns true if the device is not enabled
+      # @return [Boolean]
+      def closed?
+        !@enabled
+      end
+
       # Add attributes for the device instance
       # :direction, :id, :name
       def self.included(base)

data/lib/unimidi/input/buffer_access.rb

@@ -35,7 +35,7 @@ module UniMIDI
       # Gets any messages in the buffer in the same format as Input#gets_data. . This doesn't remove
       # the messages from the buffer or have any effect on the StreamReader pointer position
       # @param [*Object] args
-      # @return [Array<Fixnum>]
+      # @return [Array<Integer>]
       def gets_buffer_data(*args)
         @device.buffer.map { |msg| msg[:data] }
       end

data/lib/unimidi/input/stream_reader.rb

@@ -56,7 +56,7 @@ module UniMIDI
       #   [144, 60, 100, 128, 60, 100, 144, 40, 120]
       #
       # @param [*Object] args
-      # @return [Array<Fixnum>]
+      # @return [Array<Integer>]
       def gets_data(*args)
         arr = gets(*args)
         arr.map { |msg| msg[:data] }.inject(:+)

data/lib/unimidi/loader.rb

@@ -1,29 +1,32 @@
 module UniMIDI
 
   # Populate UniMIDI devices using the underlying device objects from the platform-specific gems
-  module Loader
+  class Loader
 
-    extend self
+    class << self
 
-    # Use the given platform-specific adapter to load devices
-    # @param [UniMIDI::Adapter::Loader] loader
-    def use(loader)
-      @loader = loader
-    end
+      # 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
-        }
+      # Get all MIDI devices
+      # @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
-      options[:direction].nil? ? @devices.values.flatten : @devices[options[:direction]]
+
     end
 
   end

data/lib/unimidi/output.rb

@@ -12,7 +12,7 @@ module UniMIDI
       Loader.devices(:direction => :output)
     end
 
-    # Sends a message to the output. 
+    # Sends a message to the output.
     #
     # The message format can be:
     #
@@ -21,18 +21,18 @@ module UniMIDI
     # 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>]
+    # @param [*Array<Integer>, *Array<String>, *Integer, *String] messages
+    # @return [Array<Integer>, Array<String>]
     def puts(*messages)
       message = messages.first
       case message
       when Array then messages.each { |array| puts(*array.flatten) }
-      when Fixnum then puts_bytes(*messages)
+      when Integer 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) 
+        elsif message.respond_to?(:to_a)
           puts_bytes(*message.to_a.flatten)
         end
       end
@@ -51,8 +51,8 @@ module UniMIDI
 
     # 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>>]
+    # @param [*Array<Integer>] messages
+    # @return [Array<Integer>, Array<Array<Integer>>]
     def puts_bytes(*messages)
       @device.puts_bytes(*messages)
       messages.count < 2 ? messages[0] : messages

data/lib/unimidi/platform.rb

@@ -4,23 +4,31 @@ module UniMIDI
   module Platform
 
     extend self
-    
+
     # Loads the proper MIDI library and adapter for the user's environment
     def bootstrap
-      lib = case RUBY_PLATFORM
+      require("unimidi/adapter/#{platform_lib}")
+      Loader.use(platform_module::Loader)
+    end
+
+    private
+
+    def platform_lib
+      case RUBY_PLATFORM
         when /darwin/ then "ffi-coremidi"
         when /java/ then "midi-jruby"
         when /linux/ then "alsa-rawmidi"
         when /mingw/ then "midi-winmm"
       end
-      require("unimidi/adapter/#{lib}")
-      interface = case RUBY_PLATFORM
+    end
+
+    def platform_module
+      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,17 +1,17 @@
 module UniMIDI
-  
+
   # Utility for converting between different data formats
   module TypeConversion
 
     extend self
-      
-    # Convert an array of numeric bytes to string of hex bytes 
-    # @param [Array<Fixnum>] byte An array of numeric bytes eg [0x90, 0x40, 0x40]
+
+    # Convert an array of numeric bytes to string of hex bytes
+    # @param [Array<Integer>] byte An array of numeric bytes eg [0x90, 0x40, 0x40]
     # @return [String] A string of hex bytes eg "904040"
     def numeric_byte_array_to_hex_string(bytes)
       bytes.map { |b| b.to_s(16) }.join
     end
-      
+
   end
-  
+
 end

data/test/helper.rb

@@ -1,5 +1,5 @@
 dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + '/../lib'
+$LOAD_PATH.unshift("#{dir}/../lib")
 
 require "minitest/autorun"
 require "mocha/test_unit"
@@ -8,67 +8,4 @@ require "unimidi"
 
 module TestHelper
 
-  extend self
-
-  def sysex_ok?
-    ENV["_system_name"] != "OSX" || !RUBY_PLATFORM.include?("java")
-  end
-
-  def devices
-    if @devices.nil?
-      @devices = {}
-      { :input => UniMIDI::Input, :output => UniMIDI::Output }.each do |type, klass|
-        @devices[type] = klass.gets
-      end
-    end
-    @devices
-  end
-
-  def bytestrs_to_ints(arr)
-    data = arr.map { |m| m[:data] }.join
-    output = []
-    until (bytestr = data.slice!(0,2)).eql?("")
-      output << bytestr.hex
-    end
-    output
-  end
-
-  class MIDIObj
-    def initialize(*bytes)
-      @bytes = bytes
-    end
-    def to_bytes
-      @bytes
-    end
-  end
-
-  def message_objects
-    numeric_messages.map { |message| MIDIObj.new(*message) }
-  end
-
-  def numeric_messages
-    messages = [
-      [0x90, 100, 100], # note on
-      [0x90, 43, 100], # note on
-      [0x90, 76, 100], # note on
-      [0x90, 60, 100], # note on
-      [0x80, 100, 100] # note off
-    ]
-    if sysex_ok?
-      messages << [0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7]
-    end
-    messages
-  end
-
-  def string_messages
-    messages = [
-      "906440", # note on
-      "804340" # note off
-    ]
-    if sysex_ok?
-      messages << "F04110421240007F0041F7"
-    end
-    messages
-  end
-
 end

data/test/integration/helper.rb

@@ -0,0 +1,76 @@
+require "helper"
+require "minitest/autorun"
+require "mocha/test_unit"
+require "shoulda-context"
+require "unimidi"
+
+module TestHelper
+
+  module Integration
+
+    extend self
+
+    def sysex_ok?
+      ENV["_system_name"] != "OSX" || !RUBY_PLATFORM.include?("java")
+    end
+
+    def devices
+      if @devices.nil?
+        @devices = {}
+        { :input => UniMIDI::Input, :output => UniMIDI::Output }.each do |type, klass|
+          @devices[type] = klass.gets
+        end
+      end
+      @devices
+    end
+
+    def bytestrs_to_ints(arr)
+      data = arr.map { |m| m[:data] }.join
+      output = []
+      until (bytestr = data.slice!(0,2)).eql?("")
+        output << bytestr.hex
+      end
+      output
+    end
+
+    class MIDIObj
+      def initialize(*bytes)
+        @bytes = bytes
+      end
+      def to_bytes
+        @bytes
+      end
+    end
+
+    def message_objects
+      numeric_messages.map { |message| MIDIObj.new(*message) }
+    end
+
+    def numeric_messages
+      messages = [
+        [0x90, 100, 100], # note on
+        [0x90, 43, 100], # note on
+        [0x90, 76, 100], # note on
+        [0x90, 60, 100], # note on
+        [0x80, 100, 100] # note off
+      ]
+      if sysex_ok?
+        messages << [0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7]
+      end
+      messages
+    end
+
+    def string_messages
+      messages = [
+        "906440", # note on
+        "804340" # note off
+      ]
+      if sysex_ok?
+        messages << "F04110421240007F0041F7"
+      end
+      messages
+    end
+
+  end
+  
+end

data/test/{input_test.rb → integration/input_test.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require "integration/helper"
 
 class UniMIDI::InputTest < Minitest::Test
 
@@ -8,9 +8,9 @@ class UniMIDI::InputTest < Minitest::Test
 
       setup do
         sleep(1)
-        @input = TestHelper.devices[:input].open
-        @output = TestHelper.devices[:output].open
-        @messages = TestHelper.numeric_messages
+        @input = TestHelper::Integration.devices[:input].open
+        @output = TestHelper::Integration.devices[:output].open
+        @messages = TestHelper::Integration.numeric_messages
         @bytes = []
       end
 

data/test/{functional_test.rb → integration/io_test.rb}

@@ -1,13 +1,13 @@
-require "helper"
+require "integration/helper"
 
-class UniMIDI::FunctionalTest < Minitest::Test
+class UniMIDI::IoTest < Minitest::Test
 
   # ** these tests assume that TestOutput is connected to TestInput
   context "UniMIDI" do
 
     setup do
-      @input = TestHelper.devices[:input].open
-      @output = TestHelper.devices[:output].open
+      @input = TestHelper::Integration.devices[:input].open
+      @output = TestHelper::Integration.devices[:output].open
     end
 
     teardown do
@@ -20,7 +20,7 @@ class UniMIDI::FunctionalTest < Minitest::Test
       context "using numeric bytes" do
 
         setup do
-          @messages = TestHelper.numeric_messages
+          @messages = TestHelper::Integration.numeric_messages
           @messages_arr = @messages.inject(&:+).flatten
           @received_arr = []
           @pointer = 0
@@ -48,7 +48,7 @@ class UniMIDI::FunctionalTest < Minitest::Test
       context "using byte Strings" do
 
         setup do
-          @messages = TestHelper.string_messages
+          @messages = TestHelper::Integration.string_messages
           @messages_str = @messages.join
           @received_str = ""
           @pointer = 0
@@ -78,7 +78,7 @@ class UniMIDI::FunctionalTest < Minitest::Test
       context "using MIDIMessages" do
 
         setup do
-          @messages = TestHelper.message_objects
+          @messages = TestHelper::Integration.message_objects
           @messages_arr = @messages.map(&:to_bytes).flatten
           @received_arr = []
           @pointer = 0

data/test/unit/device_test.rb

@@ -0,0 +1,197 @@
+require "unit/helper"
+
+class UniMIDI::DeviceTest < Minitest::Test
+
+  context "Device" do
+
+    setup do
+      UniMIDI::Input.stubs(:all).returns(TestHelper::Unit.mock_devices[:input])
+      UniMIDI::Output.stubs(:all).returns(TestHelper::Unit.mock_devices[:output])
+    end
+
+    teardown do
+      UniMIDI::Input.unstub(:all)
+      UniMIDI::Output.unstub(:all)
+    end
+
+    context "InstanceMethods" do
+
+      context "Device#type" do
+
+        context "input" do
+
+          setup do
+            @input = UniMIDI::Input.all.sample
+          end
+
+          should "be an input" do
+            assert_equal(:input, @input.type)
+          end
+
+        end
+
+        context "output" do
+
+          setup do
+            UniMIDI::Input.stubs(:all).returns(TestHelper::Unit.mock_devices[:input])
+            @output = UniMIDI::Output.all.sample
+          end
+
+          should "be an output" do
+            assert_equal(:output, @output.type)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "ClassMethods" do
+
+      context ".find_by_name" do
+
+        setup do
+          @name = UniMIDI::Output.all.map(&:name).sample
+          @output = UniMIDI::Output.find_by_name(@name)
+        end
+
+        should "select the correct input" do
+          assert_equal(@name, @output.name)
+        end
+
+      end
+
+      context ".first" do
+
+        setup do
+          @output_to_test = UniMIDI::Output.all[0]
+          @output_to_test.expects(:open).returns(true)
+          @output_to_test.expects(:enabled?).returns(true)
+          @output = UniMIDI::Output.first
+        end
+
+        teardown do
+          @output_to_test.unstub(:open)
+          @output_to_test.unstub(:enabled?)
+        end
+
+        should "return the first output" do
+          assert_equal(@output_to_test, @output)
+        end
+
+      end
+
+      context ".last" do
+
+        setup do
+          @output_to_test = UniMIDI::Output.all.last
+          @output_to_test.expects(:open).returns(true)
+          @output_to_test.expects(:enabled?).returns(true)
+          @output = UniMIDI::Output.last
+        end
+
+        teardown do
+          @output_to_test.unstub(:open)
+          @output_to_test.unstub(:enabled?)
+        end
+
+        should "return the last output" do
+          assert_equal @output_to_test, @output
+        end
+
+      end
+
+      context ".[]" do
+
+        setup do
+          @device_to_test = UniMIDI::Input.all[0]
+          @device_to_test.expects(:open).returns(true)
+          @device_to_test.expects(:enabled?).returns(true)
+          @device = UniMIDI::Input[0]
+        end
+
+        teardown do
+          @device_to_test.unstub(:open)
+          @device_to_test.unstub(:enabled?)
+        end
+
+        should "return correct input" do
+          assert_equal(@device_to_test, @device)
+        end
+
+      end
+
+      context ".use" do
+
+        context "block given" do
+
+          setup do
+            @device_to_test = UniMIDI::Input.all.sample
+            @index = UniMIDI::Input.all.index(@device_to_test)
+            @device_to_test.expects(:open).returns(true)
+            @device_to_test.expects(:enabled?).at_least_once.returns(true)
+          end
+
+          teardown do
+            @device_to_test.unstub(:open)
+            @device_to_test.unstub(:enabled?)
+          end
+
+          should "return and enable an input" do
+            @device = nil
+            UniMIDI::Input.use(@index) do |device|
+              @device = device
+              assert(@device.enabled?)
+            end
+            assert_equal(UniMIDI::Input.at(@index), @device)
+          end
+
+        end
+
+        context "with symbol" do
+
+          setup do
+            @device_to_test = UniMIDI::Output.all.sample
+            @index = UniMIDI::Output.all.index(@device_to_test)
+            @device_to_test.expects(:open).returns(true)
+            @device_to_test.expects(:enabled?).at_least_once.returns(true)
+          end
+
+          teardown do
+            @device_to_test.unstub(:open)
+            @device_to_test.unstub(:enabled?)
+          end
+
+          should "return an enabled input" do
+            @device = UniMIDI::Output.use(@index)
+            assert(@device.enabled?)
+            assert_equal(UniMIDI::Output.at(@index), @device)
+          end
+
+        end
+
+      end
+
+      context ".count" do
+
+        setup do
+          @inputs = UniMIDI::Input.all
+          @outputs = UniMIDI::Output.all
+        end
+
+        should "have the correct number of inputs" do
+          assert_equal(@inputs.count, UniMIDI::Input.count)
+        end
+
+        should "have the correct number of outputs" do
+          assert_equal(@outputs.count, UniMIDI::Output.count)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/helper.rb

@@ -0,0 +1,40 @@
+require "helper"
+require "minitest/autorun"
+require "mocha/test_unit"
+require "shoulda-context"
+require "unimidi"
+
+module TestHelper
+
+  module Unit
+
+    extend self
+
+    def sysex_ok?
+      ENV["_system_name"] != "OSX" || !RUBY_PLATFORM.include?("java")
+    end
+
+    def mock_devices
+      if @mock_devices.nil?
+        @mock_devices = {
+          input: [],
+          output: []
+        }
+        2.times do |i|
+          input = Object.new
+          input.stubs(:type).returns(:input)
+          input.stubs(:name).returns("MIDI Input #{i}")
+          @mock_devices[:input] << input
+        end
+        3.times do |i|
+          input = Object.new
+          input.stubs(:type).returns(:output)
+          input.stubs(:name).returns("MIDI Output #{i}")
+          @mock_devices[:output] << input
+        end
+      end
+      @mock_devices
+    end
+
+  end
+end

data/test/unit/platform_test.rb

@@ -0,0 +1,37 @@
+require "unit/helper"
+
+class UniMIDI::PlatformTest < Minitest::Test
+
+  context "Platform" do
+
+    context ".bootstrap" do
+
+      if RUBY_PLATFORM.include?("java")
+        should "recognize java" do
+          assert_equal(UniMIDI::Adapter::MIDIJRuby::Loader, UniMIDI::Loader.instance_variable_get("@loader"))
+        end
+      end
+
+      if RUBY_PLATFORM.include?("linux")
+        should "recognize linux" do
+          assert_equal(UniMIDI::Adapter::AlsaRawMIDI::Loader, UniMIDI::Loader.instance_variable_get("@loader"))
+        end
+      end
+
+      if RUBY_PLATFORM.include?("darwin")
+        should "recognize osx" do
+          assert_equal(UniMIDI::Adapter::CoreMIDI::Loader, UniMIDI::Loader.instance_variable_get("@loader"))
+        end
+      end
+
+      if RUBY_PLATFORM.include?("mingw")
+        should "recognize windows" do
+          assert_equal(UniMIDI::Adapter::MIDIWinMM::Loader, UniMIDI::Loader.instance_variable_get("@loader"))
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/{type_conversion_test.rb → unit/type_conversion_test.rb}

@@ -1,4 +1,4 @@
-require 'helper'
+require "unit/helper"
 
 class UniMIDI::TypeConversionTest < Minitest::Test
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unimidi
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-18 00:00:00.000000000 Z
+date: 2017-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -193,16 +193,17 @@ files:
 - lib/unimidi/output.rb
 - lib/unimidi/platform.rb
 - lib/unimidi/type_conversion.rb
-- test/adapter_test.rb
-- test/class_methods_test.rb
-- test/functional_test.rb
 - test/helper.rb
-- test/input_test.rb
-- test/platform_test.rb
-- test/type_conversion_test.rb
+- test/integration/helper.rb
+- test/integration/input_test.rb
+- test/integration/io_test.rb
+- test/unit/device_test.rb
+- test/unit/helper.rb
+- test/unit/platform_test.rb
+- test/unit/type_conversion_test.rb
 homepage: http://github.com/arirusso/unimidi
 licenses:
-- Apache 2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -220,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: unimidi
-rubygems_version: 2.4.6
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Realtime MIDI IO for Ruby

data/test/adapter_test.rb

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

data/test/class_methods_test.rb

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

data/test/platform_test.rb

@@ -1,47 +0,0 @@
-require 'helper'
-
-class UniMIDI::PlatformTest < Minitest::Test
-
-  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
-    refute_equal(input_class, UniMIDI::Input)
-    refute_equal(output_class, UniMIDI::Output)
-    refute_equal(device_class, UniMIDI::Device)
-    assert_equal(input_class.first.name, UniMIDI::Input.first.name)
-    assert_equal(input_class.first.id, UniMIDI::Input.first.id)
-    refute_equal(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
-
-  context "Platform" do
-
-    should "recognize java" do
-      if RUBY_PLATFORM.include?("java")
-        platform_test(UniMIDI::Adapter::MIDIJRuby, ::MIDIJRuby)
-      end
-    end
-
-    should "recognize linux" do
-      if RUBY_PLATFORM.include?("linux")
-        platform_test(UniMIDI::Adapter::AlsaRawMIDI, ::AlsaRawMIDI)
-      end
-    end
-
-    should "recognize osx" do
-      if RUBY_PLATFORM.include?("darwin")
-        platform_test(UniMIDI::Adapter::CoreMIDI, ::CoreMIDI, ::CoreMIDI::Endpoint, ::CoreMIDI::Source, ::CoreMIDI::Destination)
-      end
-    end
-
-    should "recognize windows" do
-      if RUBY_PLATFORM.include?("mingw")
-        platform_test(UniMIDI::Adapter::MIDIWinMM, ::MIDIWinMM)
-      end
-    end
-
-  end
-
-end