ffi-coremidi 0.3.8 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b89ec50ebb1e9fd6bca17f28dbfb065e85edb4ee
-  data.tar.gz: d213dd0c938562dab97afe5d262fec5fcb1b491d
+SHA256:
+  metadata.gz: d05cb8f763c856b651e7fa5f94499350bc7576cd210e7402ce26bc9bbd714739
+  data.tar.gz: 77a98c6abc53d0287bc4e57d7f3cce217da9e32d73fd6a3205602f0c6bd69fbe
 SHA512:
-  metadata.gz: 810f3b9da5ec4e3bc9f85962fc82e56fa6e41fb022bae10364bdf57285b3a8d448a770eac869955f522f23fb6a6ded6c314eb6a924d5453eabad8cdbfd840323
-  data.tar.gz: e7f2022a340fe38364d409e4c26cf30a5721cd367e9174a8b3c57f38bd1441f5e9ece9337a505a0aa2a775ae247e45832e1e1abb643e3b224a7b3701ebfc0adc
+  metadata.gz: fc172a0d02c6fc6efd3d1337623e92fdf9bb4b01e08debe2105ed78bb306d49db44308d72cc0041cd04ee04ecb50f4ebda935610bcf18dab67afb2b90e1a5d9b
+  data.tar.gz: bbdcf6d8e87f2896db09859e79b6d8c39f33ea2046a10704d917439d7974e50224ed842414ece048e99d671943da7939e47cef74ae3e4683ee4ccdf54646687b

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2011-2015 Ari Russo
+Copyright 2011-2022 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

@@ -48,4 +48,4 @@ Also thank you to [Jeremy Voorhis](http://github.com/jvoorhis) for some useful d
 
 Apache 2.0, See the file LICENSE
 
-Copyright (c) 2011-2015 [Ari Russo](http://github.com/arirusso)
+Copyright (c) 2011-2022 [Ari Russo](http://github.com/arirusso)

data/lib/coremidi/api.rb

@@ -1,8 +1,8 @@
-module CoreMIDI
+# frozen_string_literal: true
 
+module CoreMIDI
   # Coremidi C binding
   module API
-
     extend FFI::Library
     ffi_lib '/System/Library/Frameworks/CoreMIDI.framework/Versions/Current/CoreMIDI'
 
@@ -17,12 +17,11 @@ module CoreMIDI
     typedef :pointer, :MIDIEntityRef
     typedef :pointer, :MIDIObjectRef
     typedef :pointer, :MIDIPortRef
-    #typedef :pointer, :MIDIReadProc
+    # typedef :pointer, :MIDIReadProc
     typedef :uint32, :MIDITimeStamp
     typedef :int32, :OSStatus
 
     class MIDISysexSendRequest < FFI::Struct
-
       layout :destination,         :MIDIEndpointRef,
              :data,                :pointer,
              :bytes_to_send,       :uint32,
@@ -33,18 +32,15 @@ module CoreMIDI
     end
 
     class MIDIPacket < FFI::Struct
-
       layout :timestamp, :MIDITimeStamp,
              :nothing, :uint32, # no idea...
              :length, :uint16,
              :data, [:uint8, 256]
-
     end
 
     class MIDIPacketList < FFI::Struct
       layout :numPackets, :uint32,
              :packet, [MIDIPacket.by_value, 1]
-
     end
 
     def self.get_callback(*args, &block)
@@ -53,7 +49,7 @@ module CoreMIDI
 
     # Pack the given data into a coremidi MIDI packet (used by Destination)
     def self.get_midi_packet(data)
-      format = "C" * data.size
+      format = 'C' * data.size
       packed_data = data.pack(format)
       char_size = FFI.type_size(:char) * data.size
       bytes = FFI::MemoryPointer.new(char_size)
@@ -67,8 +63,8 @@ module CoreMIDI
       error = API.MIDIClientCreate(client_name, nil, nil, client_pointer)
       client = client_pointer.read_pointer
       {
-        :error => error,
-        :resource => client
+        error: error,
+        resource: client
       }
     end
 
@@ -78,8 +74,8 @@ module CoreMIDI
       error = API.MIDIInputPortCreate(client, port_name, callback, nil, handle_ptr)
       handle = handle_ptr.read_pointer
       {
-        :error => error,
-        :handle => handle
+        error: error,
+        handle: handle
       }
     end
 
@@ -89,8 +85,8 @@ module CoreMIDI
       error = API.MIDIOutputPortCreate(client, port_name, port_pointer)
       handle = port_pointer.read_pointer
       {
-        :error => error,
-        :handle => handle
+        error: error,
+        handle: handle
       }
     end
 
@@ -100,17 +96,18 @@ module CoreMIDI
       packet_ptr = API.MIDIPacketListInit(packet_list)
       time = HostTime.AudioGetCurrentHostTime
       packet_ptr = if X86_64
-        API.MIDIPacketListAdd(packet_list, 256, packet_ptr, time, size, bytes)
-      else
-        # Pass in two 32-bit 0s for the 64 bit time
-        time1 = API.MIDIPacketListAdd(packet_list, 256, packet_ptr, time >> 32, time & 0xFFFFFFFF, size, bytes)
-      end
+                     API.MIDIPacketListAdd(packet_list, 256, packet_ptr, time, size, bytes)
+                   else
+                     # Pass in two 32-bit 0s for the 64 bit time
+                     time1 = API.MIDIPacketListAdd(packet_list, 256, packet_ptr, time >> 32, time & 0xFFFFFFFF, size,
+                                                   bytes)
+                   end
       packet_list
     end
 
     # @param [FFI::Pointer] resource A pointer to an underlying struct
     # @param [String, Symbol] name The property name to get
-    # @return [Fixnum]
+    # @return [Integer]
     def self.get_int(resource, name)
       property = API::CF.CFStringCreateWithCString(nil, name.to_s, 0)
       value = FFI::MemoryPointer.new(:pointer, 32)
@@ -132,7 +129,7 @@ module CoreMIDI
         bytes = FFI::MemoryPointer.new(length + 1)
 
         if CF.CFStringGetCString(string, bytes, length + 1, :kCFStringEncodingUTF8)
-          bytes.read_string.force_encoding("utf-8")
+          bytes.read_string.force_encoding('utf-8')
         end
       ensure
         CF.CFRelease(string) unless string.nil? || string.null?
@@ -145,13 +142,13 @@ module CoreMIDI
     callback :MIDIReadProc, [MIDIPacketList.by_ref, :pointer, :pointer], :pointer
 
     # OSStatus MIDIClientCreate(CFStringRef name, MIDINotifyProc notifyProc, void *notifyRefCon, MIDIClientRef *outClient);
-    attach_function :MIDIClientCreate, [:pointer, :pointer, :pointer, :pointer], :int
+    attach_function :MIDIClientCreate, %i[pointer pointer pointer pointer], :int
 
     # OSStatus MIDIClientDispose(MIDIClientRef client);
     attach_function :MIDIClientDispose, [:pointer], :int
 
     # MIDIEntityRef MIDIDeviceGetEntity(MIDIDeviceRef  device, ItemCount entityIndex0);
-    attach_function :MIDIDeviceGetEntity, [:MIDIDeviceRef, :ItemCount], :MIDIEntityRef
+    attach_function :MIDIDeviceGetEntity, %i[MIDIDeviceRef ItemCount], :MIDIEntityRef
 
     # MIDIEndpointRef MIDIGetDestination(ItemCount destIndex0);
     attach_function :MIDIGetNumberOfDestinations, [], :ItemCount
@@ -162,11 +159,11 @@ module CoreMIDI
     # MIDIEndpointRef MIDIEntityGetDestination(MIDIEntityRef entity, ItemCount destIndex0);
     attach_function :MIDIGetDestination, [:int], :pointer
 
-    #extern OSStatus MIDIEndpointDispose( MIDIEndpointRef endpt );
+    # extern OSStatus MIDIEndpointDispose( MIDIEndpointRef endpt );
     attach_function :MIDIEndpointDispose, [:MIDIEndpointRef], :OSStatus
 
     # MIDIEndpointRef MIDIEntityGetDestination( MIDIEntityRef entity, ItemCount destIndex0 );
-    attach_function :MIDIEntityGetDestination, [:MIDIEntityRef, :int], :MIDIEndpointRef
+    attach_function :MIDIEntityGetDestination, %i[MIDIEntityRef int], :MIDIEndpointRef
 
     # ItemCount MIDIEntityGetNumberOfDestinations (MIDIEntityRef  entity);
     attach_function :MIDIEntityGetNumberOfDestinations, [:MIDIEntityRef], :ItemCount
@@ -175,77 +172,76 @@ module CoreMIDI
     attach_function :MIDIEntityGetNumberOfSources, [:MIDIEntityRef], :ItemCount
 
     # MIDIEndpointRef MIDIEntityGetSource (MIDIEntityRef  entity, ItemCount sourceIndex0);
-    attach_function :MIDIEntityGetSource, [:MIDIEntityRef, :ItemCount], :MIDIEndpointRef
+    attach_function :MIDIEntityGetSource, %i[MIDIEntityRef ItemCount], :MIDIEndpointRef
 
     # MIDIDeviceRef MIDIGetDevice(ItemCount deviceIndex0);
     attach_function :MIDIGetDevice, [:ItemCount], :MIDIDeviceRef
 
     # extern OSStatus MIDIInputPortCreate( MIDIClientRef client, CFStringRef portName,
     #                                      MIDIReadProc readProc, void * refCon, MIDIPortRef * outPort );
-    attach_function :MIDIInputPortCreate, [:MIDIClientRef, :CFStringRef, :MIDIReadProc, :pointer, :MIDIPortRef], :OSStatus
+    attach_function :MIDIInputPortCreate, %i[MIDIClientRef CFStringRef MIDIReadProc pointer MIDIPortRef],
+                    :OSStatus
 
     # extern OSStatus MIDIObjectGetIntegerProperty( MIDIObjectRef obj, CFStringRef propertyID, SInt32 * outValue );
-    attach_function :MIDIObjectGetIntegerProperty, [:MIDIObjectRef, :CFStringRef, :pointer], :OSStatus
+    attach_function :MIDIObjectGetIntegerProperty, %i[MIDIObjectRef CFStringRef pointer], :OSStatus
 
     # OSStatus MIDIObjectGetStringProperty (MIDIObjectRef  obj, CFStringRef propertyID, CFStringRef *str);
-    attach_function :MIDIObjectGetStringProperty, [:MIDIObjectRef, :CFStringRef, :pointer], :OSStatus
+    attach_function :MIDIObjectGetStringProperty, %i[MIDIObjectRef CFStringRef pointer], :OSStatus
 
     # extern OSStatus MIDIOutputPortCreate( MIDIClientRef client, CFStringRef portName, MIDIPortRef * outPort );
-    attach_function :MIDIOutputPortCreate, [:MIDIClientRef, :CFStringRef, :pointer], :int
+    attach_function :MIDIOutputPortCreate, %i[MIDIClientRef CFStringRef pointer], :int
 
     # (MIDIPacket*) MIDIPacketListInit(MIDIPacketList *pktlist);
     attach_function :MIDIPacketListInit, [:pointer], :pointer
 
-    #extern OSStatus MIDIPortConnectSource( MIDIPortRef port, MIDIEndpointRef source, void * connRefCon )
-    attach_function :MIDIPortConnectSource, [:MIDIPortRef, :MIDIEndpointRef, :pointer], :OSStatus
+    # extern OSStatus MIDIPortConnectSource( MIDIPortRef port, MIDIEndpointRef source, void * connRefCon )
+    attach_function :MIDIPortConnectSource, %i[MIDIPortRef MIDIEndpointRef pointer], :OSStatus
 
-    #extern OSStatus MIDIPortDisconnectSource( MIDIPortRef port, MIDIEndpointRef source );
-    attach_function :MIDIPortDisconnectSource, [:MIDIPortRef, :MIDIEndpointRef], :OSStatus
+    # extern OSStatus MIDIPortDisconnectSource( MIDIPortRef port, MIDIEndpointRef source );
+    attach_function :MIDIPortDisconnectSource, %i[MIDIPortRef MIDIEndpointRef], :OSStatus
 
-    #extern OSStatus MIDIPortDispose(MIDIPortRef port );
+    # extern OSStatus MIDIPortDispose(MIDIPortRef port );
     attach_function :MIDIPortDispose, [:MIDIPortRef], :OSStatus
 
-    #extern OSStatus MIDISend(MIDIPortRef port,MIDIEndpointRef dest,const MIDIPacketList *pktlist);
-    attach_function :MIDISend, [:MIDIPortRef, :MIDIEndpointRef, :pointer], :int
+    # extern OSStatus MIDISend(MIDIPortRef port,MIDIEndpointRef dest,const MIDIPacketList *pktlist);
+    attach_function :MIDISend, %i[MIDIPortRef MIDIEndpointRef pointer], :int
 
-    #OSStatus MIDISendSysex(MIDISysexSendRequest *request);
+    # OSStatus MIDISendSysex(MIDISysexSendRequest *request);
     attach_function :MIDISendSysex, [:pointer], :int
 
     # extern MIDIPacket * MIDIPacketListAdd( MIDIPacketList * pktlist, ByteCount listSize,
     #                                        MIDIPacket * curPacket, MIDITimeStamp time,
     #                                        ByteCount nData, const Byte * data)
     if X86_64
-      attach_function :MIDIPacketListAdd, [:pointer, :int, :pointer, :uint64, :int, :pointer], :pointer
+      attach_function :MIDIPacketListAdd, %i[pointer int pointer uint64 int pointer], :pointer
     else
-      attach_function :MIDIPacketListAdd, [:pointer, :int, :pointer, :int, :int, :int, :pointer], :pointer
+      attach_function :MIDIPacketListAdd, %i[pointer int pointer int int int pointer], :pointer
     end
 
     module CF
-
       extend FFI::Library
       ffi_lib '/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation'
 
       typedef :pointer, :CFStringRef
       typedef :long, :CFIndex
-      enum :CFStringEncoding, [ :kCFStringEncodingUTF8, 0x08000100 ]
+      enum :CFStringEncoding, [:kCFStringEncodingUTF8, 0x08000100]
 
       # CFString* CFStringCreateWithCString( ?, CString, encoding)
-      attach_function :CFStringCreateWithCString, [:pointer, :string, :int], :pointer
+      attach_function :CFStringCreateWithCString, %i[pointer string int], :pointer
       # CString* CFStringGetCStringPtr(CFString*, encoding)
-      attach_function :CFStringGetCStringPtr, [:pointer, :int], :pointer
+      attach_function :CFStringGetCStringPtr, %i[pointer int], :pointer
 
       # CFIndex CFStringGetLength(CFStringRef theString);
-      attach_function :CFStringGetLength, [ :CFStringRef ], :CFIndex
+      attach_function :CFStringGetLength, [:CFStringRef], :CFIndex
 
       # CFIndex CFStringGetMaximumSizeForEncoding(CFIndex length, CFStringEncoding encoding);
-      attach_function :CFStringGetMaximumSizeForEncoding, [ :CFIndex, :CFStringEncoding ], :long
+      attach_function :CFStringGetMaximumSizeForEncoding, %i[CFIndex CFStringEncoding], :long
 
       # Boolean CFStringGetCString(CFStringRef theString, char *buffer, CFIndex bufferSize, CFStringEncoding encoding);
-      attach_function :CFStringGetCString, [ :CFStringRef, :pointer, :CFIndex, :CFStringEncoding ], :bool
+      attach_function :CFStringGetCString, %i[CFStringRef pointer CFIndex CFStringEncoding], :bool
 
       # void CFRelease (CFTypeRef cf);
-      attach_function :CFRelease, [ :pointer ], :void
-
+      attach_function :CFRelease, [:pointer], :void
     end
 
     module HostTime
@@ -257,7 +253,5 @@ module CoreMIDI
       # UInt64 AudioGetCurrentHostTime()
       attach_function :AudioGetCurrentHostTime, [], :uint64
     end
-
   end
-
 end

data/lib/coremidi/destination.rb

@@ -1,8 +1,8 @@
-module CoreMIDI
+# frozen_string_literal: true
 
+module CoreMIDI
   # Type of endpoint used for output
   class Destination
-
     include Endpoint
 
     attr_reader :entity
@@ -24,41 +24,41 @@ module CoreMIDI
     def puts_s(data)
       data = data.dup
       bytes = []
-      until (str = data.slice!(0,2)).eql?("")
+      until (str = data.slice!(0, 2)).eql?('')
         bytes << str.hex
       end
       puts_bytes(*bytes)
       true
     end
-    alias_method :puts_bytestr, :puts_s
-    alias_method :puts_hex, :puts_s
+    alias puts_bytestr puts_s
+    alias puts_hex puts_s
 
     # Send a MIDI message comprised of numeric bytes
-    # @param [*Fixnum] data Numeric bytes eg 0x90, 0x40, 0x40
+    # @param [*Integer] data Numeric bytes eg 0x90, 0x40, 0x40
     # @return [Boolean]
     def puts_bytes(*data)
       type = sysex?(data) ? :sysex : :small
       bytes = API.get_midi_packet(data)
-      send("puts_#{type.to_s}", bytes, data.size)
+      send("puts_#{type}", bytes, data.size)
       true
     end
 
     # Send a MIDI message of indeterminate type
-    # @param [*Array<Fixnum>, *Array<String>, *Fixnum, *String] args
+    # @param [*Array<Integer>, *Array<String>, *Integer, *String] args
     # @return [Boolean]
     def puts(*args)
       case args.first
       when Array then args.each { |arg| puts(*arg) }
-      when Fixnum then puts_bytes(*args)
+      when Integer then puts_bytes(*args)
       when String then puts_bytestr(*args)
       end
     end
-    alias_method :write, :puts
+    alias write puts
 
     # Enable this device
     # @return [Destination]
-    def enable(options = {}, &block)
-      @enabled = true unless @enabled
+    def enable(_options = {})
+      @enabled ||= true
       if block_given?
         begin
           yield(self)
@@ -68,8 +68,8 @@ module CoreMIDI
       end
       self
     end
-    alias_method :open, :enable
-    alias_method :start, :enable
+    alias open enable
+    alias start enable
 
     # Shortcut to the first output endpoint available
     # @return [Destination]
@@ -97,10 +97,10 @@ module CoreMIDI
     def connect
       client_error = enable_client
       port_error = initialize_port
-      @resource = API.MIDIEntityGetDestination( @entity.resource, @resource_id )
+      @resource = API.MIDIEntityGetDestination(@entity.resource, @resource_id)
       !@resource.address.zero? && client_error.zero? && port_error.zero?
     end
-    alias_method :connect?, :connect
+    alias connect? connect
 
     private
 
@@ -126,7 +126,7 @@ module CoreMIDI
 
     SysexCompletionCallback =
       API.get_callback([:pointer]) do |sysex_request_ptr|
-      # this isn't working for some reason. as of now, it's not needed though
+        # this isn't working for some reason. as of now, it's not needed though
       end
 
     # Initialize a coremidi port for this endpoint
@@ -140,7 +140,5 @@ module CoreMIDI
     def sysex?(data)
       data.first.eql?(0xF0) && data.last.eql?(0xF7)
     end
-
   end
-
 end

data/lib/coremidi/device.rb

@@ -1,17 +1,17 @@
-module CoreMIDI
+# frozen_string_literal: true
 
-  # A MIDI device may have multiple logically distinct sub-components. For example, one device may 
-  # encompass a MIDI synthesizer and a pair of MIDI ports, both addressable via a USB port. Each 
+module CoreMIDI
+  # A MIDI device may have multiple logically distinct sub-components. For example, one device may
+  # encompass a MIDI synthesizer and a pair of MIDI ports, both addressable via a USB port. Each
   # such element of a device is called a MIDI entity.
   #
   # https://developer.apple.com/library/ios/documentation/CoreMidi/Reference/MIDIServices_Reference/Reference/reference.html
   class Device
-
     attr_reader :entities,
                 :id, # Unique Numeric id
                 :name # Device name from coremidi
 
-    # @param [Fixnum] id The ID for the device
+    # @param [Integer] id The ID for the device
     # @param [Object] device_pointer The underlying device pointer
     # @param [Hash] options
     # @option options [Boolean] :include_offline Whether to include offline entities (default: false)
@@ -21,20 +21,20 @@ module CoreMIDI
       @entities = []
       populate(options)
     end
-            
+
     # Endpoints for this device
     # @return [Array<Endpoint>]
     def endpoints
-      endpoints = { :source => [], :destination => [] }
-      endpoints.keys.each do |key|
+      endpoints = { source: [], destination: [] }
+      endpoints.each_key do |key|
         endpoint_group = entities.map { |entity| entity.endpoints[key] }.flatten
         endpoints[key] += endpoint_group
       end
       endpoints
     end
-    
+
     # Assign all of this Device's endpoints an consecutive local id
-    # @param [Integer] last_id The highest already used endpoint ID 
+    # @param [Integer] last_id The highest already used endpoint ID
     # @return [Integer] The highest used endpoint ID after populating this device's endpoints
     def populate_endpoint_ids(last_id)
       id = 0
@@ -53,8 +53,8 @@ module CoreMIDI
       if !populated? || !use_cache
         @devices = []
         counter = 0
-        while !(device_pointer = API.MIDIGetDevice(counter)).null?
-          device = new(counter, device_pointer, :include_offline => include_offline)
+        until (device_pointer = API.MIDIGetDevice(counter)).null?
+          device = new(counter, device_pointer, include_offline: include_offline)
           @devices << device
           counter += 1
         end
@@ -72,17 +72,17 @@ module CoreMIDI
 
     # Has the device list been populated?
     def self.populated?
-      !@devices.nil? && !@devices.empty? 
+      !@devices.nil? && !@devices.empty?
     end
 
     private
 
     # Populate the device name
     def populate_name
-      @name = API.get_string(@resource, "name")
-      raise RuntimeError.new("Can't get device name") unless @name
+      @name = API.get_string(@resource, 'name')
+      raise "Can't get device name" unless @name
     end
-    
+
     # All of the endpoints for all devices a consecutive local id
     def self.populate_endpoint_ids
       counter = 0
@@ -93,12 +93,12 @@ module CoreMIDI
     # Populates the entities for this device. These entities are in turn used to gather the endpoints.
     # @param [Hash] options
     # @option options [Boolean] :include_offline Whether to include offline entities (default: false)
-    # @return [Fixnum] The number of entities populated
+    # @return [Integer] The number of entities populated
     def populate_entities(options = {})
       include_if_offline = options[:include_offline] || false
       i = 0
-      while !(entity_pointer = API.MIDIDeviceGetEntity(@resource, i)).null?
-        @entities << Entity.new(entity_pointer, :include_offline => include_if_offline)
+      until (entity_pointer = API.MIDIDeviceGetEntity(@resource, i)).null?
+        @entities << Entity.new(entity_pointer, include_offline: include_if_offline)
         i += 1
       end
       i
@@ -107,9 +107,7 @@ module CoreMIDI
     # Populate the instance
     def populate(options = {})
       populate_name
-      populate_entities(:include_offline => options[:include_offline])
+      populate_entities(include_offline: options[:include_offline])
     end
-
   end
-
 end

data/lib/coremidi/endpoint.rb

@@ -1,10 +1,10 @@
-module CoreMIDI
+# frozen_string_literal: true
 
+module CoreMIDI
   # A source or destination of a 16-channel MIDI stream
   #
   # https://developer.apple.com/library/ios/documentation/CoreMidi/Reference/MIDIServices_Reference/Reference/reference.html
   module Endpoint
-
     extend Forwardable
 
     attr_reader :enabled, # has the endpoint been initialized?
@@ -15,15 +15,18 @@ module CoreMIDI
 
     def_delegators :entity, :manufacturer, :model, :name
 
-    alias_method :enabled?, :enabled
+    alias enabled? enabled
 
-    # @param [Fixnum] resource_id
+    # @param [Integer] resource_id
     # @param [Entity] entity
     def initialize(resource_id, entity)
       @entity = entity
       @resource_id = resource_id
       @type = get_type
       @enabled = false
+
+      @threads_sync_semaphore = Mutex.new
+      @threads_waiting = []
     end
 
     # Is this endpoint online?
@@ -33,8 +36,8 @@ module CoreMIDI
     end
 
     # Set the id for this endpoint (the id is immutable)
-    # @param [Fixnum] val
-    # @return [Fixnum]
+    # @param [Integer] val
+    # @return [Integer]
     def id=(id)
       @id ||= id
     end
@@ -67,8 +70,8 @@ module CoreMIDI
     # @return [Hash]
     def self.all_by_type
       {
-        :source => sources,
-        :destination => destinations
+        source: sources,
+        destination: destinations
       }
     end
 
@@ -102,7 +105,5 @@ module CoreMIDI
       @client = client[:resource]
       client[:error]
     end
-
   end
-
 end