alsa-rawmidi 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0f58d0a3f8e6060d9315afd9534b4aec7834f196
-  data.tar.gz: 26a79750d4048440e0769805bb0576c183b3ef80
+SHA256:
+  metadata.gz: 0be8f5761da9a747ce69063ebc6b5f4242986a37574c6119d5c909e30fd4b929
+  data.tar.gz: 3db20d183d1b117c18259dd06442efa6165bf7c99e1dc0746fc07e87fd906846
 SHA512:
-  metadata.gz: f00bc3bba78d18e2017e749b708276dac2b597974dd796ec481636d59c0d2f8ca98d8afb7c2c94c47ee7f060e2797a2e3f4bf4f2a9da7f651b511c663e237523
-  data.tar.gz: 6b1d5c46be16974720e25d9347ca9b304741ed89d89689b85f620ebf386d9dd48481bb0d79faa2f9852ef3cd0d2ef8364bf74a49cf410ae85ccf534f1a9f68db
+  metadata.gz: a89bb97349a978c8557b31ed155f1d215e2aa9b957df291033c23ca51f064b08b6d7c58f808adc283783e34b0e72f2327cf1cba43d178c4be829225ece39828d
+  data.tar.gz: 7fdc7bfbce4f006f51c29a2dc9b45aebf64b92284be1fb50291267292c187d5fbc687daea44d9c2a1ea0e00761be4a57ca1f850dc78a7d6771d763c0895449b7

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2010-2017 Ari Russo
+Copyright 2010-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

@@ -45,4 +45,4 @@ Otherwise
 
 Apache 2.0, See the file LICENSE
 
-Copyright (c) 2010-2017 Ari Russo  
+Copyright (c) 2010-2022 Ari Russo  

data/lib/alsa-rawmidi/api.rb

@@ -1,18 +1,18 @@
-module AlsaRawMIDI
+# frozen_string_literal: true
 
+module AlsaRawMIDI
   # libasound RawMIDI struct, enum and function bindings
   module API
-
     extend FFI::Library
-    ffi_lib "libasound"
+    ffi_lib 'libasound'
 
     CONSTANTS = {
-      :SND_RAWMIDI_STREAM_OUTPUT => 0,
-      :SND_RAWMIDI_STREAM_INPUT => 1,
-      :SND_RAWMIDI_APPEND => 0x0001,
-      :SND_RAWMIDI_NONBLOCK =>  0x0002,
-      :SND_RAWMIDI_SYNC =>  0x0004
-    }
+      SND_RAWMIDI_STREAM_OUTPUT: 0,
+      SND_RAWMIDI_STREAM_INPUT: 1,
+      SND_RAWMIDI_APPEND: 0x0001,
+      SND_RAWMIDI_NONBLOCK: 0x0002,
+      SND_RAWMIDI_SYNC: 0x0004
+    }.freeze
 
     typedef :ulong, :SndCtlType
     typedef :ulong, :SndCtl
@@ -21,72 +21,72 @@ module AlsaRawMIDI
     # snd_ctl
     class SndCtl < FFI::Struct
       layout :dl_handle, :pointer, # void*
-      :name, :pointer, # char*
-      :type, :SndCtlType,
-      :ops, :pointer, # const snd_ctl_ops_t*
-      :private_data, :pointer, # void*
-      :nonblock, :ulong,
-      :poll_fd, :ulong,
-      :async_handlers, :ulong
+             :name, :pointer, # char*
+             :type, :SndCtlType,
+             :ops, :pointer, # const snd_ctl_ops_t*
+             :private_data, :pointer, # void*
+             :nonblock, :ulong,
+             :poll_fd, :ulong,
+             :async_handlers, :ulong
     end
 
     # snd_ctl_card_info
     class SndCtlCardInfo < FFI::Struct
       layout :card, :int, # card number
-      :pad, :int, # reserved for future (was type)
-      :id, [:uchar, 16], # ID of card (user selectable)
-      :driver, [:uchar, 16], # Driver name
-      :name, [:uchar, 32], # Short name of soundcard
-      :longname, [:uchar, 80], # name + info text about soundcard
-      :reserved_, [:uchar, 16], # reserved for future (was ID of mixer)
-      :mixername, [:uchar, 80], # visual mixer identification
-      :components, [:uchar, 128] # card components / fine identification, delimited with one space (AC97 etc..)
+             :pad, :int, # reserved for future (was type)
+             :id, [:uchar, 16], # ID of card (user selectable)
+             :driver, [:uchar, 16], # Driver name
+             :name, [:uchar, 32], # Short name of soundcard
+             :longname, [:uchar, 80], # name + info text about soundcard
+             :reserved_, [:uchar, 16], # reserved for future (was ID of mixer)
+             :mixername, [:uchar, 80], # visual mixer identification
+             :components, [:uchar, 128] # card components / fine identification, delimited with one space (AC97 etc..)
     end
 
     # snd_rawmidi_info
     class SndRawMIDIInfo < FFI::Struct
       layout :device, :uint, # RO/WR (control): device number
-      :subdevice, :uint, # RO/WR (control): subdevice number
-      :stream, :int, # WR: stream
-      :card, :int, # R: card number
-      :flags, :uint, # SNDRV_RAWMIDI_INFO_XXXX
-      :id, [:uchar, 64], # ID (user selectable)
-      :name, [:uchar, 80], # name of device
-      :subname, [:uchar, 32], # name of active or selected subdevice
-      :subdevices_count, :uint,
-      :subdevices_avail, :uint,
-      :reserved, [:uchar, 64] # reserved for future use
+             :subdevice, :uint, # RO/WR (control): subdevice number
+             :stream, :int, # WR: stream
+             :card, :int, # R: card number
+             :flags, :uint, # SNDRV_RAWMIDI_INFO_XXXX
+             :id, [:uchar, 64], # ID (user selectable)
+             :name, [:uchar, 80], # name of device
+             :subname, [:uchar, 32], # name of active or selected subdevice
+             :subdevices_count, :uint,
+             :subdevices_avail, :uint,
+             :reserved, [:uchar, 64] # reserved for future use
     end
 
     # timespec
     class Timespec < FFI::Struct
       layout :tv_sec, :time_t, # Seconds since 00:00:00 GMT
-      :tv_nsec, :long # Additional nanoseconds since
+             :tv_nsec, :long # Additional nanoseconds since
     end
 
     # snd_rawmidi_status
     class SndRawMIDIStatus < FFI::Struct
       layout :stream, :int,
-      :timestamp, Timespec.by_value, # Timestamp
-      :avail, :size_t, # available bytes
-      :xruns, :size_t, # count of overruns since last status (in bytes)
-      :reserved, [:uchar, 64] # reserved for future use
+             :timestamp, Timespec.by_value, # Timestamp
+             :avail, :size_t, # available bytes
+             :xruns, :size_t, # count of overruns since last status (in bytes)
+             :reserved, [:uchar, 64] # reserved for future use
     end
 
     # Simple doubly linked list implementation
     class LinkedList < FFI::Struct
       layout :next, :pointer, # *LinkedList
-      :prev, :pointer # *LinkedList
+             :prev, :pointer # *LinkedList
     end
 
     # snd_rawmidi
     class SndRawMIDI < FFI::Struct
       layout :card, :pointer, # *snd_card
-      :list, LinkedList.by_value,
-      :device, :uint, # device number
-      :info_flags, :uint, # SNDRV_RAWMIDI_INFO_XXXX
-      :id, [:char, 64],
-      :name, [:char, 80]
+             :list, LinkedList.by_value,
+             :device, :uint, # device number
+             :info_flags, :uint, # SNDRV_RAWMIDI_INFO_XXXX
+             :id, [:char, 64],
+             :name, [:char, 80]
     end
 
     # spinlock_t
@@ -97,7 +97,7 @@ module AlsaRawMIDI
     # wait_queue_head_t
     class WaitQueueHead < FFI::Struct
       layout :lock, Spinlock.by_value,
-      :task_list, LinkedList.by_value
+             :task_list, LinkedList.by_value
     end
 
     class AtomicT < FFI::Struct
@@ -105,43 +105,43 @@ module AlsaRawMIDI
     end
 
     class Tasklet < FFI::Struct
-      layout :next, :pointer,   # pointer to the next tasklet in the list / void (*func) (unsigned long)
-      :state, :ulong,    # state of the tasklet
-      :count, AtomicT.by_value, # reference counter
-      :func,  :pointer,  # tasklet handler function / void (*func) (unsigned long)
-      :data,  :ulong     # argument to the tasklet function
+      layout :next, :pointer, # pointer to the next tasklet in the list / void (*func) (unsigned long)
+             :state, :ulong, # state of the tasklet
+             :count, AtomicT.by_value, # reference counter
+             :func,  :pointer,  # tasklet handler function / void (*func) (unsigned long)
+             :data,  :ulong     # argument to the tasklet function
     end
 
     # snd_rawmidi_runtime
     class SndRawMIDIRuntime < FFI::Struct
       layout :drain, :uint, 1, # drain stage
-      :oss, :uint, 1, # OSS compatible mode
-      # midi stream buffer
-      :buffer, :pointer, # uchar* / buffer for MIDI data
-      :buffer_size, :size_t, # size of buffer
-      :appl_ptr, :size_t, # application pointer
-      :hw_ptr, :size_t, # hardware pointer
-      :avail_min, :size_t, # min avail for wakeup
-      :avail, :size_t, # max used buffer for wakeup
-      :xruns, :size_t, # over/underruns counter
-      # misc
-      :lock, Spinlock.by_value,
-      :sleep, WaitQueueHead.by_value,
-      # event handler (new bytes, input only)
-      :substream, :pointer, # void (*event)(struct snd_rawmidi_substream *substream);
-      # defers calls to event [input] or ops->trigger [output]
-      :tasklet, Tasklet.by_value,
-      :private_data, :pointer, # void*
-      :private_free, :pointer # void (*private_free)(struct snd_rawmidi_substream *substream)
+             :oss, :uint, 1, # OSS compatible mode
+             # midi stream buffer
+             :buffer, :pointer, # uchar* / buffer for MIDI data
+             :buffer_size, :size_t, # size of buffer
+             :appl_ptr, :size_t, # application pointer
+             :hw_ptr, :size_t, # hardware pointer
+             :avail_min, :size_t, # min avail for wakeup
+             :avail, :size_t, # max used buffer for wakeup
+             :xruns, :size_t, # over/underruns counter
+             # misc
+             :lock, Spinlock.by_value,
+             :sleep, WaitQueueHead.by_value,
+             # event handler (new bytes, input only)
+             :substream, :pointer, # void (*event)(struct snd_rawmidi_substream *substream);
+             # defers calls to event [input] or ops->trigger [output]
+             :tasklet, Tasklet.by_value,
+             :private_data, :pointer, # void*
+             :private_free, :pointer # void (*private_free)(struct snd_rawmidi_substream *substream)
     end
 
     # snd_rawmidi_params
     class SndRawMIDIParams < FFI::Struct
       layout :stream, :int,
-      :buffer_size, :size_t, # queue size in bytes
-      :avail_min, :size_t, # minimum avail bytes for wakeup
-      :no_active_sensing, :uint, 1, # do not send active sensing byte in close()
-      :reserved, [:uchar, 16] # reserved for future use
+             :buffer_size, :size_t, # queue size in bytes
+             :avail_min, :size_t, # minimum avail bytes for wakeup
+             :no_active_sensing, :uint, 1, # do not send active sensing byte in close()
+             :reserved, [:uchar, 16] # reserved for future use
     end
 
     #
@@ -155,30 +155,30 @@ module AlsaRawMIDI
     # Convert card string to an integer value.
     attach_function :snd_card_get_index, [:pointer], :int # (const char* name)
     # Obtain the card name.
-    attach_function :snd_card_get_name, [:int, :pointer], :int # (int card, char **name)
+    attach_function :snd_card_get_name, %i[int pointer], :int # (int card, char **name)
     # Obtain the card long name.
-    attach_function :snd_card_get_longname, [:int, :pointer], :int # (int card, char **name)
+    attach_function :snd_card_get_longname, %i[int pointer], :int # (int card, char **name)
 
     #
     # snd_ctl
     #
 
     # Opens a CTL.
-    attach_function :snd_ctl_open, [:pointer, :pointer, :int], :int #  (snd_ctl_t **ctl, const char *name, int mode)
+    attach_function :snd_ctl_open, %i[pointer pointer int], :int #  (snd_ctl_t **ctl, const char *name, int mode)
     # Opens a CTL using local configuration.
-    attach_function :snd_ctl_open_lconf, [:pointer, :pointer, :int, :pointer], :int # (snd_ctl_t **ctl, const char *name, int mode, snd_config_t *lconf)
+    attach_function :snd_ctl_open_lconf, %i[pointer pointer int pointer], :int # (snd_ctl_t **ctl, const char *name, int mode, snd_config_t *lconf)
     # close CTL handle
-    attach_function :snd_ctl_close, [:pointer], :int #(snd_ctl_t *ctl)
+    attach_function :snd_ctl_close, [:pointer], :int # (snd_ctl_t *ctl)
     # set nonblock mode
-    attach_function :snd_ctl_nonblock, [:pointer, :int], :int # (snd_ctl_t *ctl, int nonblock)
+    attach_function :snd_ctl_nonblock, %i[pointer int], :int # (snd_ctl_t *ctl, int nonblock)
     # Get card related information.
-    attach_function :snd_ctl_card_info, [:pointer, :pointer], :int # (snd_ctl_t *ctl, snd_ctl_card_info_t *info)
+    attach_function :snd_ctl_card_info, %i[pointer pointer], :int # (snd_ctl_t *ctl, snd_ctl_card_info_t *info)
     # Get card name from a CTL card info.
     attach_function :snd_ctl_card_info_get_name, [:pointer], :string # (const snd_ctl_card_info_t *obj) / const char*
     # Get info about a RawMidi device.
-    attach_function :snd_ctl_rawmidi_info, [:SndCtl, :pointer], :int # (snd_ctl_t *ctl, snd_rawmidi_info_t *info)
+    attach_function :snd_ctl_rawmidi_info, %i[SndCtl pointer], :int # (snd_ctl_t *ctl, snd_rawmidi_info_t *info)
     # Get next RawMidi device number.
-    attach_function :snd_ctl_rawmidi_next_device, [:SndCtl, :pointer], :int # (snd_ctl_t *ctl, int *device)
+    attach_function :snd_ctl_rawmidi_next_device, %i[SndCtl pointer], :int # (snd_ctl_t *ctl, int *device)
 
     #
     # snd_rawmidi
@@ -191,36 +191,36 @@ module AlsaRawMIDI
     # drop all bytes in the rawmidi I/O ring buffer immediately
     attach_function :snd_rawmidi_drop, [:SndRawMIDI], :int # int ( snd_rawmidi_t * rawmidi)
     # set nonblock mode
-    attach_function :snd_rawmidi_nonblock, [:SndRawMIDI, :int], :int # (snd_rawmidi_t *rmidi, int nonblock)
+    attach_function :snd_rawmidi_nonblock, %i[SndRawMIDI int], :int # (snd_rawmidi_t *rmidi, int nonblock)
     # Opens a new connection to the RawMidi interface.
-    attach_function :snd_rawmidi_open, [:pointer, :pointer, :string, :int], :int # (snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, const char *name, int mode)
+    attach_function :snd_rawmidi_open, %i[pointer pointer string int], :int # (snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, const char *name, int mode)
     # Opens a new connection to the RawMidi interface using local configuration.
-    attach_function :snd_rawmidi_open_lconf, [:pointer, :pointer, :string, :int, :pointer], :int #(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, const char *name, int mode, snd_config_t *lconf)
+    attach_function :snd_rawmidi_open_lconf, %i[pointer pointer string int pointer], :int # (snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, const char *name, int mode, snd_config_t *lconf)
     # read MIDI bytes from MIDI stream
-    attach_function :snd_rawmidi_read, [:SndRawMIDI, :pointer, :size_t], :ssize_t # (snd_rawmidi_t *rmidi, void *buffer, size_t size)
+    attach_function :snd_rawmidi_read, %i[SndRawMIDI pointer size_t], :ssize_t # (snd_rawmidi_t *rmidi, void *buffer, size_t size)
     # write MIDI bytes to MIDI stream
-    attach_function :snd_rawmidi_write, [:SndRawMIDI, :ulong, :size_t], :ssize_t # (snd_rawmidi_t *rmidi, const void *buffer, size_t size)
+    attach_function :snd_rawmidi_write, %i[SndRawMIDI ulong size_t], :ssize_t # (snd_rawmidi_t *rmidi, const void *buffer, size_t size)
 
     #
     # snd_rawmidi_info
     #
 
     enum :snd_rawmidi_stream, [
-      "SND_RAWMIDI_STREAM_OUTPUT", 0,
-      "SND_RAWMIDI_STREAM_INPUT", 1,
-      "SND_RAWMIDI_STREAM_LAST", 1
+      'SND_RAWMIDI_STREAM_OUTPUT', 0,
+      'SND_RAWMIDI_STREAM_INPUT', 1,
+      'SND_RAWMIDI_STREAM_LAST', 1
     ]
 
     # get information about RawMidi handle
-    attach_function :snd_rawmidi_info, [:pointer, :pointer], :int # (snd_rawmidi_t *rmidi, snd_rawmidi_info_t *info)
+    attach_function :snd_rawmidi_info, %i[pointer pointer], :int # (snd_rawmidi_t *rmidi, snd_rawmidi_info_t *info)
     # get rawmidi count of subdevices
     attach_function :snd_rawmidi_info_get_subdevices_count, [:pointer], :uint # (const snd_rawmidi_info_t *obj)
     # set rawmidi device number
-    attach_function :snd_rawmidi_info_set_device, [:pointer, :uint], :void # (snd_rawmidi_info_t *obj, unsigned int val)
+    attach_function :snd_rawmidi_info_set_device, %i[pointer uint], :void # (snd_rawmidi_info_t *obj, unsigned int val)
     # set rawmidi subdevice number
-    attach_function :snd_rawmidi_info_set_subdevice, [:pointer, :uint], :void # (snd_rawmidi_info_t *obj, unsigned int val)
+    attach_function :snd_rawmidi_info_set_subdevice, %i[pointer uint], :void # (snd_rawmidi_info_t *obj, unsigned int val)
     # set rawmidi stream identifier
-    attach_function :snd_rawmidi_info_set_stream, [:pointer, :snd_rawmidi_stream], :void # (snd_rawmidi_info_t *obj, snd_rawmidi_stream_t val)
+    attach_function :snd_rawmidi_info_set_stream, %i[pointer snd_rawmidi_stream], :void # (snd_rawmidi_info_t *obj, snd_rawmidi_stream_t val)
     # get size of the snd_rawmidi_info_t structure in bytes
     attach_function :snd_rawmidi_info_sizeof, [], :size_t # (void)
 
@@ -235,17 +235,16 @@ module AlsaRawMIDI
 
     # Wrapper for ALSA methods dealing with input
     module Input
-
       BUFFER_SIZE = 256
 
-      extend self
+      module_function
 
       # Open the output with the given ID
       # @param [Integer] id
       # @return [Integer]
       def open(id)
         API::Device.open(id) do |pointer|
-          API.snd_rawmidi_open(pointer, nil, id,  API::CONSTANTS[:SND_RAWMIDI_NONBLOCK])
+          API.snd_rawmidi_open(pointer, nil, id, API::CONSTANTS[:SND_RAWMIDI_NONBLOCK])
         end
       end
 
@@ -253,30 +252,29 @@ module AlsaRawMIDI
       # @return [String]
       def poll(handle)
         buffer = FFI::MemoryPointer.new(:uint8, BUFFER_SIZE)
-        if (err = API.snd_rawmidi_read(handle, buffer, BUFFER_SIZE)) < 0
-          raise "Can't read MIDI input: #{API.snd_strerror(err)}" unless err.eql?(-11)
+        if (err = API.snd_rawmidi_read(handle, buffer, BUFFER_SIZE)) < (0) && !err.eql?(-11)
+          raise "Can't read MIDI input: #{API.snd_strerror(err)}"
         end
+
         # Upon success, err is positive and equal to the number of bytes read
         # into the buffer.
-        if err > 0
-          bytes = buffer.get_bytes(0,err).unpack("a*").first.unpack("H*")
+        if err.positive?
+          bytes = buffer.get_bytes(0, err).unpack1('a*').unpack('H*')
           bytes.first.upcase
         end
       end
-
     end
 
     # Wrapper for ALSA methods dealing with output
     module Output
-
-      extend self
+      module_function
 
       # Send the given MIDI data to the output with the given handle
       # @param [Integer] handle
       # @param [Array<Integer>] data
       # @return [Boolean]
       def puts(handle, data)
-        format = "C" * data.size
+        format = 'C' * data.size
         pointer = FFI::MemoryPointer.new(data.size)
         bytes = pointer.put_bytes(0, data.pack(format))
 
@@ -293,22 +291,20 @@ module AlsaRawMIDI
           API.snd_rawmidi_open(nil, pointer, id, 0)
         end
       end
-
     end
 
     # Wrapper for ALSA methods dealing with devices
     module Device
-
-      extend self
+      module_function
 
       # @param [Integer] id
       # @param [Symbol] direction
       # @return [SndCtlCardInfo]
       def get_info(id, direction)
         stream_key = case direction
-        when :input then :SND_RAWMIDI_STREAM_INPUT
-        when :output then :SND_RAWMIDI_STREAM_OUTPUT
-        end
+                     when :input then :SND_RAWMIDI_STREAM_INPUT
+                     when :output then :SND_RAWMIDI_STREAM_OUTPUT
+                     end
         stream = API::CONSTANTS[stream_key]
         info = API::SndRawMIDIInfo.new
         API.snd_rawmidi_info_set_device(info.pointer, id)
@@ -329,18 +325,16 @@ module AlsaRawMIDI
       # @param [Integer] id
       # @param [Proc] block
       # @return [Integer]
-      def open(id, &block)
+      def open(_id)
         handle_pointer = FFI::MemoryPointer.new(FFI.type_size(:int))
         yield(handle_pointer)
         handle_pointer.read_int
       end
-
     end
 
     # Wrapper for ALSA methods dealing with the soundcard and subdevices
     module Soundcard
-
-      extend self
+      module_function
 
       # @param [SndCtlCardInfo] info
       # @return [Integer]
@@ -355,9 +349,9 @@ module AlsaRawMIDI
       # @param [Integer] id
       # @return [String]
       def get_subdevice_id(soundcard_id, device_id, subdev_count, id)
-        ext = (subdev_count > 1) ? ",#{id}" : ''
+        ext = subdev_count > 1 ? ",#{id}" : ''
         name = API::Soundcard.get_name(soundcard_id)
-        "#{name},#{device_id.to_s}#{ext}"
+        "#{name},#{device_id}#{ext}"
       end
 
       # @param [SndCtlCardInfo] info
@@ -374,7 +368,7 @@ module AlsaRawMIDI
       # @param [Symbol] direction
       # @param [Proc] block
       # @return [Array<Object>]
-      def get_subdevices(direction, soundcard_id, device_id, &block)
+      def get_subdevices(direction, soundcard_id, device_id)
         handle = API::Soundcard.get_handle(soundcard_id)
         info = API::Device.get_info(device_id, direction)
         i = 0
@@ -385,9 +379,9 @@ module AlsaRawMIDI
             subdev_count = API::Soundcard.get_subdevice_count(info) if i.zero?
             system_id = API::Soundcard.get_subdevice_id(soundcard_id, device_id, subdev_count, i)
             device_hash = {
-              :id => system_id,
-              :name => info[:name].to_s,
-              :subname => info[:subname].to_s
+              id: system_id,
+              name: info[:name].to_s,
+              subname: info[:subname].to_s
             }
             available << yield(device_hash)
             i += 1
@@ -411,7 +405,7 @@ module AlsaRawMIDI
       # @param [Integer] soundcard_id
       # @return [String]
       def get_name(soundcard_id)
-        "hw:#{soundcard_id.to_s}"
+        "hw:#{soundcard_id}"
       end
 
       # Does a soundcard exist for the given id?
@@ -428,8 +422,6 @@ module AlsaRawMIDI
         API.snd_ctl_open(handle_pointer, get_name(soundcard_id), 0)
         handle_pointer.read_int
       end
-
     end
-
   end
 end

data/lib/alsa-rawmidi/device.rb

@@ -1,10 +1,9 @@
-module AlsaRawMIDI
+# frozen_string_literal: true
 
+module AlsaRawMIDI
   # Functionality common to both inputs and outputs
   module Device
-
     module ClassMethods
-
       # Select the first device of the given direction
       # @param [Symbol] direction
       # @return [Input, Output]
@@ -37,38 +36,37 @@ module AlsaRawMIDI
       # @return [Hash]
       def get_devices
         available_devices = {
-          :input => [],
-          :output => []
+          input: [],
+          output: []
         }
         device_count = 0
         32.times do |i|
           card = Soundcard.find(i)
-          unless card.nil?
-            available_devices.keys.each do |direction|
-              devices = card.subdevices[direction]
-              devices.each do |dev|
-                dev.send(:id=, device_count)
-                device_count += 1
-              end
-              available_devices[direction] += devices
+          next if card.nil?
+
+          available_devices.each_key do |direction|
+            devices = card.subdevices[direction]
+            devices.each do |dev|
+              dev.send(:id=, device_count)
+              device_count += 1
             end
+            available_devices[direction] += devices
           end
         end
         available_devices
       end
-
     end
 
     extend ClassMethods
 
     attr_reader :enabled, # has the device been initialized?
-    :system_id, # the alsa id of the device
-    :id, # a local uuid for the device
-    :name,
-    :subname,
-    :type # :input or :output
+                :system_id, # the alsa id of the device
+                :id, # a local uuid for the device
+                :name,
+                :subname,
+                :type # :input or :output
 
-    alias_method :enabled?, :enabled
+    alias enabled? enabled
 
     def self.included(base)
       base.send(:extend, ClassMethods)
@@ -102,7 +100,5 @@ module AlsaRawMIDI
     def get_type
       self.class.name.split('::').last.downcase.to_sym
     end
-
   end
-
 end

data/lib/alsa-rawmidi/input.rb

@@ -1,8 +1,8 @@
-module AlsaRawMIDI
+# frozen_string_literal: true
 
+module AlsaRawMIDI
   # Input device class
   class Input
-
     include Device
 
     attr_reader :buffer
@@ -25,7 +25,7 @@ module AlsaRawMIDI
       @pointer = @buffer.length
       msgs
     end
-    alias_method :read, :gets
+    alias read gets
 
     # Like Input#gets but returns message data as string of hex digits as such:
     #   [
@@ -37,17 +37,17 @@ module AlsaRawMIDI
     # @return [Array<Hash>]
     def gets_s
       msgs = gets
-      msgs.each { |m| m[:data] = numeric_bytes_to_hex_string(m[:data]) }
+      msgs.each { |m| m[:data] = TypeConversion.numeric_bytes_to_hex_string(m[:data]) }
       msgs
     end
-    alias_method :gets_bytestr, :gets_s
-    alias_method :gets_hex, :gets_s
+    alias gets_bytestr gets_s
+    alias gets_hex gets_s
 
     # Enable this the input for use; yields
     # @param [Hash] options
     # @param [Proc] block
     # @return [Input] self
-    def enable(options = {}, &block)
+    def enable(_options = {})
       unless @enabled
         @start_time = Time.now.to_f
         @resource = API::Input.open(@system_id)
@@ -64,8 +64,8 @@ module AlsaRawMIDI
       end
       self
     end
-    alias_method :open, :enable
-    alias_method :start, :enable
+    alias open enable
+    alias start enable
 
     # Close this input
     # @return [Boolean]
@@ -125,8 +125,8 @@ module AlsaRawMIDI
     # @return [Hash]
     def get_message_formatted(hexstring, timestamp)
       {
-        :data => hex_string_to_numeric_bytes(hexstring),
-        :timestamp => timestamp
+        data: TypeConversion.hex_string_to_numeric_bytes(hexstring),
+        timestamp: timestamp
       }
     end
 
@@ -146,7 +146,7 @@ module AlsaRawMIDI
     # and holds them for the next call to gets*
     # @return [Thread]
     def spawn_listener
-      interval = 1.0/1000
+      interval = 1.0 / 1000
       @listener = Thread.new do
         begin
           loop do
@@ -155,8 +155,8 @@ module AlsaRawMIDI
             end
             populate_buffer(messages) unless messages.nil?
           end
-        rescue Exception => exception
-          Thread.main.raise(exception)
+        rescue Exception => e
+          Thread.main.raise(e)
         end
       end
       @listener.abort_on_exception = true
@@ -168,32 +168,5 @@ module AlsaRawMIDI
     def populate_buffer(messages)
       @buffer << get_message_formatted(messages, now) unless messages.nil?
     end
-
-    # Convert a hex string to an array of numeric bytes eg "904040" -> [0x90, 0x40, 0x40]
-    # @param [String] string
-    # @return [Array<Integer>]
-    def hex_string_to_numeric_bytes(string)
-      string = string.dup
-      bytes = []
-      until string.length.zero?
-        string_byte = string.slice!(0, 2)
-        bytes << string_byte.hex
-      end
-      bytes
-    end
-
-    # Convert an array of numeric bytes to a hex string eg [0x90, 0x40, 0x40] -> "904040"
-    # @param [Array<Integer>] bytes
-    # @return [String]
-    def numeric_bytes_to_hex_string(bytes)
-      string_bytes = bytes.map do |byte|
-        string_byte = byte.to_s(16).upcase
-        string_byte = "0#{string_byte}" if byte < 16
-        string_byte
-      end
-      string_bytes.join
-    end
-
   end
-
 end

data/lib/alsa-rawmidi/output.rb

@@ -1,8 +1,8 @@
-module AlsaRawMIDI
+# frozen_string_literal: true
 
+module AlsaRawMIDI
   # Output device class
   class Output
-
     include Device
 
     # Close this output
@@ -23,14 +23,14 @@ module AlsaRawMIDI
     def puts_s(data)
       data = data.dup
       output = []
-      until (str = data.slice!(0,2)) == ""
+      until (str = data.slice!(0, 2)) == ''
         output << str.hex
       end
       puts_bytes(*output)
       true
     end
-    alias_method :puts_bytestr, :puts_s
-    alias_method :puts_hex, :puts_s
+    alias puts_bytestr puts_s
+    alias puts_hex puts_s
 
     # Output a MIDI message in numeric byte format
     # @param [*Integer] data
@@ -45,18 +45,18 @@ module AlsaRawMIDI
     # @return [Boolean]
     def puts(*args)
       case args.first
-        when Array then args.each { |arg| puts(*arg) }
-        when Numeric then puts_bytes(*args)
-        when String then puts_bytestr(*args)
+      when Array then args.each { |arg| puts(*arg) }
+      when Numeric then puts_bytes(*args)
+      when String then puts_bytestr(*args)
       end
     end
-    alias_method :write, :puts
+    alias write puts
 
     # Enable this device; yields
     # @param [Hash] options
     # @param [Proc] block
     # @return [Output]
-    def enable(options = {}, &block)
+    def enable(_options = {})
       unless @enabled
         @resource = API::Output.open(@system_id)
         @enabled = true
@@ -70,8 +70,8 @@ module AlsaRawMIDI
       end
       self
     end
-    alias_method :open, :enable
-    alias_method :start, :enable
+    alias open enable
+    alias start enable
 
     # The first available output
     # @return [Output]
@@ -90,7 +90,5 @@ module AlsaRawMIDI
     def self.all
       Device.all_by_type[:output]
     end
-
   end
-
 end

data/lib/alsa-rawmidi/soundcard.rb

@@ -1,14 +1,14 @@
-module AlsaRawMIDI
+# frozen_string_literal: true
 
+module AlsaRawMIDI
   class Soundcard
-
     attr_reader :id, :subdevices
 
     # @param [Integer] id
     def initialize(id)
       @subdevices = {
-        :input => [],
-        :output => []
+        input: [],
+        output: []
       }
       @id = id
       populate_subdevices
@@ -19,9 +19,7 @@ module AlsaRawMIDI
     # @return [Soundcard]
     def self.find(id)
       @soundcards ||= {}
-      if API::Soundcard.exists?(id)
-        @soundcards[id] ||= Soundcard.new(id)
-      end
+      @soundcards[id] ||= Soundcard.new(id) if API::Soundcard.exists?(id)
     end
 
     private
@@ -30,7 +28,7 @@ module AlsaRawMIDI
     def populate_subdevices
       device_ids = API::Soundcard.get_device_ids(@id)
       device_ids.each do |device_id|
-        @subdevices.keys.each do |direction|
+        @subdevices.each_key do |direction|
           devices = API::Soundcard.get_subdevices(direction, @id, device_id) do |device_hash|
             new_device(direction, device_hash)
           end
@@ -45,17 +43,15 @@ module AlsaRawMIDI
     # @return [Input, Output]
     def new_device(direction, device_hash)
       device_class = case direction
-      when :input then Input
-      when :output then Output
-      end
+                     when :input then Input
+                     when :output then Output
+                     end
       device_properties = {
-        :system_id => device_hash[:id],
-        :name => device_hash[:name],
-        :subname => device_hash[:subname]
+        system_id: device_hash[:id],
+        name: device_hash[:name],
+        subname: device_hash[:subname]
       }
       device_class.new(device_properties)
     end
-
   end
-
 end

data/lib/alsa-rawmidi/type_conversion.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module AlsaRawMIDI
+  # Helper for converting MIDI data
+  module TypeConversion
+    module_function
+
+    # Convert a hex string to an array of numeric bytes eg "904040" -> [0x90, 0x40, 0x40]
+    # @param [String] string
+    # @return [Array<Integer>]
+    def hex_string_to_numeric_bytes(string)
+      string = string.dup
+      bytes = []
+      until string.length.zero?
+        string_byte = string.slice!(0, 2)
+        bytes << string_byte.hex
+      end
+      bytes
+    end
+
+    # Convert an array of numeric bytes to a hex string eg [0x90, 0x40, 0x40] -> "904040"
+    # @param [Array<Integer>] bytes
+    # @return [String]
+    def numeric_bytes_to_hex_string(bytes)
+      string_bytes = bytes.map do |byte|
+        string_byte = byte.to_s(16).upcase
+        string_byte = "0#{string_byte}" if byte < 16
+        string_byte
+      end
+      string_bytes.join
+    end
+  end
+end

data/lib/alsa-rawmidi/version.rb

@@ -1,5 +1,5 @@
-module AlsaRawMIDI
-
-  VERSION = "0.3.2"
+# frozen_string_literal: true
 
+module AlsaRawMIDI
+  VERSION = '0.4.0'
 end

data/lib/alsa-rawmidi.rb

@@ -1,25 +1,27 @@
+# frozen_string_literal: true
+
 #
 # alsa-rawmidi
 # ALSA Driver Interface
 #
-# (c) 2010-2014 Ari Russo
+# (c) 2010-2022 Ari Russo
 # Licensed under Apache 2.0
 # https://github.com/arirusso/alsa-rawmidi
 #
 
 # libs
-require "ffi"
+require 'ffi'
 
 # modules
-require "alsa-rawmidi/api"
-require "alsa-rawmidi/device"
-require "alsa-rawmidi/version"
+require 'alsa-rawmidi/api'
+require 'alsa-rawmidi/device'
+require 'alsa-rawmidi/type_conversion'
+require 'alsa-rawmidi/version'
 
 # class
-require "alsa-rawmidi/input"
-require "alsa-rawmidi/output"
-require "alsa-rawmidi/soundcard"
+require 'alsa-rawmidi/input'
+require 'alsa-rawmidi/output'
+require 'alsa-rawmidi/soundcard'
 
 module AlsaRawMIDI
-
 end

metadata

@@ -1,29 +1,95 @@
 --- !ruby/object:Gem::Specification
 name: alsa-rawmidi
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Ari Russo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-06-07 00:00:00.000000000 Z
+date: 2022-02-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.15'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.5
 description: Realtime MIDI IO with Ruby for Linux via the ALSA RawMIDI API.
 email:
 - ari.russo@gmail.com
@@ -39,15 +105,13 @@ files:
 - lib/alsa-rawmidi/input.rb
 - lib/alsa-rawmidi/output.rb
 - lib/alsa-rawmidi/soundcard.rb
+- lib/alsa-rawmidi/type_conversion.rb
 - lib/alsa-rawmidi/version.rb
-- test/helper.rb
-- test/input_buffer_test.rb
-- test/io_test.rb
 homepage: http://github.com/arirusso/alsa-rawmidi
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -60,11 +124,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements: []
-rubyforge_project: alsa-rawmidi
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Realtime MIDI IO with Ruby for Linux
 test_files: []

data/test/helper.rb

@@ -1,51 +0,0 @@
-dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + "/../lib"
-
-require "test/unit"
-require "mocha/test_unit"
-require "shoulda-context"
-require "alsa-rawmidi"
-
-module TestHelper
-
-  extend self
-
-  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
-
-  # some MIDI messages
-  def numeric_messages
-    [
-      [0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], # SysEx
-      [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
-    ]
-  end
-
-  # some MIDI messages
-  def string_messages
-    [
-      "F04110421240007F0041F7", # SysEx
-      "906440", # note on
-      "804340" # note off
-    ]
-  end
-
-  def input
-    AlsaRawMIDI::Input.first
-  end
-
-  def output
-    AlsaRawMIDI::Output.first
-  end
-
-end

data/test/input_buffer_test.rb

@@ -1,46 +0,0 @@
-require "helper"
-
-class AlsaRawMIDI::InputBufferTest < Test::Unit::TestCase
-
-  context "AlsaRawMIDI" do
-
-    setup do
-      sleep(1)
-      @input = TestHelper.input.open
-      @output = TestHelper.output.open
-      @input.buffer.clear
-      @pointer = 0
-    end
-
-    context "Source#buffer" do
-
-      setup do
-        @messages = TestHelper.numeric_messages
-        @messages_arr = @messages.inject(&:+).flatten
-        @received_arr = []
-      end
-
-      teardown do
-        @input.close
-        @output.close
-      end
-
-      should "have the correct messages in the buffer" do
-        bytes = []
-        @messages.each do |message|
-          p "sending: #{message}"
-          @output.puts(message)
-          bytes += message
-
-          sleep(1)
-
-          buffer = @input.buffer.map { |m| m[:data] }.flatten
-          p "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

data/test/io_test.rb

@@ -1,80 +0,0 @@
-require "helper"
-
-class AlsaRawMIDI::IoTest < Test::Unit::TestCase
-
-  # ** this test assumes that TestOutput is connected to TestInput
-  context "AlsaRawMIDI" do
-
-    setup do
-      sleep(1)
-      @input = TestHelper.input.open
-      @output = TestHelper.output.open
-      @input.buffer.clear
-      @pointer = 0
-    end
-
-    context "full IO" do
-
-      context "using Arrays" do
-
-        setup do
-          @messages = TestHelper.numeric_messages
-          @messages_arr = @messages.inject(&:+).flatten
-          @received_arr = []
-        end
-
-        teardown do
-          @input.close
-          @output.close
-        end
-        
-        should "do IO" do
-          @messages.each do |message|
-
-            p "sending: #{message}"
-
-            @output.puts(message)
-            sleep(1)
-            received = @input.gets.map { |m| m[:data] }.flatten
-
-            p "received: #{received}"
-
-            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
-
-      context "using byte Strings" do
-
-        setup do
-          @messages = TestHelper.string_messages
-          @messages_str = @messages.join
-          @received_str = ""
-        end
-
-        should "do IO" do
-          @messages.each do |message|
-
-            p "sending: #{message}"
-
-            @output.puts(message)
-            sleep(1)
-            received = @input.gets_bytestr.map { |m| m[:data] }.flatten.join
-            p "received: #{received}"
-
-            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
-
-end