libusb 0.6.4-x64-mingw32 → 0.7.1-x64-mingw32

data/lib/libusb/ss_companion.rb

@@ -19,13 +19,21 @@ module LIBUSB
   # A structure representing the superspeed endpoint companion descriptor.
   #
   # This descriptor is documented in section 9.6.7 of the USB 3.0 specification. All multiple-byte fields are represented in host-endian format.
-  class SsCompanion < FFI::ManagedStruct
+  class SsCompanion < FFI::Struct
+    include ContextReference
+
     layout :bLength, :uint8,
         :bDescriptorType, :uint8,
         :bMaxBurst, :uint8,
         :bmAttributes, :uint8,
         :wBytesPerInterval, :uint16
 
+    def initialize(ctx, *args)
+      super(*args)
+
+      register_context(ctx, :libusb_free_ss_endpoint_companion_descriptor)
+    end
+
     # Size of this descriptor (in bytes)
     def bLength
       self[:bLength]
@@ -60,10 +68,5 @@ module LIBUSB
     def inspect
       "\#<#{self.class} burst: #{bMaxBurst} attrs: #{bmAttributes}>"
     end
-
-    # @private
-    def self.release(ptr)
-      Call.libusb_free_ss_endpoint_companion_descriptor(ptr)
-    end
   end
 end

data/lib/libusb/transfer.rb

@@ -28,16 +28,16 @@ module LIBUSB
     class ZeroCopyMemory < FFI::Pointer
       attr_reader :size
 
-      def initialize(dev_handle, ptr, size)
-        @dev_handle = dev_handle
+      def initialize(pDevhandle, ptr, size)
+        @pDevhandle = pDevhandle
         @size = size
         super(ptr)
       end
 
       def free(id=nil)
+        # puts format("libusb_dev_mem_free(%#x, %d)%s", address, @size||0, id ? " by GC" : '')
         return unless @size
-#         puts format("libusb_dev_mem_free(%#x, %d)%s", address, @size, id ? " by GC" : '')
-        res = Call.libusb_dev_mem_free( @dev_handle.pHandle, self, @size )
+        res = Call.libusb_dev_mem_free( @pDevhandle, self, @size )
         LIBUSB.raise_error res, "in libusb_dev_mem_free" if res!=0
         @size = nil
       end
@@ -60,6 +60,10 @@ module LIBUSB
     def dev_handle=(dev)
       @dev_handle = dev
       @transfer[:dev_handle] = @dev_handle.pHandle
+      # Now that the transfer is bound to a DevHandle, it must be registered in the Context.
+      # This ensures that the Call::Transfer is freed before libusb_exit, avoiding warnings about still referenced devices.
+      ctx = dev.device.context.instance_variable_get(:@ctx)
+      @transfer.pointer.instance_variable_set(:@ctx, ctx.ref_context)
     end
 
     # The handle for the device to communicate with.
@@ -163,7 +167,7 @@ module LIBUSB
           ptr = Call.libusb_dev_mem_alloc( @dev_handle.pHandle, len )
 #           puts format("libusb_dev_mem_alloc(%d) => %#x", len, ptr.address)
           unless ptr.null?
-            buffer = ZeroCopyMemory.new(@dev_handle, ptr, len)
+            buffer = ZeroCopyMemory.new(@dev_handle.pHandle, ptr, len)
             ObjectSpace.define_finalizer(self, buffer.method(:free))
           end
         end
@@ -252,7 +256,7 @@ module LIBUSB
           @dev_handle.device.context.handle_events nil, @completion_flag
         rescue ERROR_INTERRUPTED
           next
-        rescue LIBUSB::Error
+        rescue Exception
           cancel!
           until @completion_flag.completed?
             @dev_handle.device.context.handle_events nil, @completion_flag

data/lib/libusb/version_gem.rb

@@ -15,5 +15,5 @@
 
 module LIBUSB
   # Library version of libusb for Ruby
-  VERSION = "0.6.4"
+  VERSION = "0.7.1"
 end

data/lib/libusb.rb

@@ -20,6 +20,7 @@ module LIBUSB
   autoload :VERSION, 'libusb/version_gem'
   autoload :Version, 'libusb/version_struct'
   autoload :Configuration, 'libusb/configuration'
+  autoload :ContextReference, 'libusb/context_reference'
   autoload :DevHandle, 'libusb/dev_handle'
   autoload :Device, 'libusb/device'
   autoload :Endpoint, 'libusb/endpoint'
@@ -32,27 +33,114 @@ module LIBUSB
     autoload klass, 'libusb/transfer'
   end
 
-  if Call.respond_to?(:libusb_get_version)
-    # Get version of the underlying libusb library.
-    # Available since libusb-1.0.10.
-    # @return [Version]  version object
-    def self.version
-      Version.new(Call.libusb_get_version)
+  class << self
+    if Call.respond_to?(:libusb_get_version)
+      # Get version of the underlying libusb library.
+      # Available since libusb-1.0.10.
+      # @return [Version]  version object
+      def version
+        Version.new(Call.libusb_get_version)
+      end
+    end
+
+    if Call.respond_to?(:libusb_has_capability)
+      # Check at runtime if the loaded library has a given capability.
+      # Available since libusb-1.0.9.
+      # @param [Symbol] capability  the {Call::Capabilities Capabilities} symbol to check for
+      # @return [Boolean]  +true+ if the running library has the capability, +false+ otherwise
+      def has_capability?(capability)
+        r = Call.libusb_has_capability(capability)
+        return r != 0
+      end
+    else
+      def has_capability?(capability)
+        false
+      end
+    end
+
+    private def expect_option_args(exp, is)
+      raise ArgumentError, "wrong number of arguments (given #{is+1}, expected #{exp+1})" if is != exp
     end
-  end
 
-  if Call.respond_to?(:libusb_has_capability)
-    # Check at runtime if the loaded library has a given capability.
-    # Available since libusb-1.0.9.
-    # @param [Symbol] capability  the {Call::Capabilities Capabilities} symbol to check for
-    # @return [Boolean]  +true+ if the running library has the capability, +false+ otherwise
-    def self.has_capability?(capability)
-      r = Call.libusb_has_capability(capability)
-      return r != 0
+    private def wrap_log_cb(block, mode)
+      if block
+        cb_proc = proc do |p_ctx, lev, str|
+          ctx = case p_ctx
+            when FFI::Pointer::NULL then nil
+            else p_ctx.to_i
+          end
+          block.call(ctx, lev, str)
+        end
+      end
+
+      # Avoid garbage collection of the proc, since only the function pointer is given to libusb
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_GLOBAL != 0
+        @log_cb_global_proc = cb_proc
+      end
+      if Call::LogCbMode.to_native(mode, nil) & LOG_CB_CONTEXT != 0
+        @log_cb_context_proc = cb_proc
+      end
+      cb_proc
+    end
+
+    private def option_args_to_ffi(option, args, ctx)
+      case option
+        when :OPTION_LOG_LEVEL, LIBUSB::OPTION_LOG_LEVEL
+          expect_option_args(1, args.length)
+          [:libusb_log_level, args[0]]
+        when :OPTION_USE_USBDK, LIBUSB::OPTION_USE_USBDK
+          expect_option_args(0, args.length)
+          []
+        when :OPTION_NO_DEVICE_DISCOVERY, LIBUSB::OPTION_NO_DEVICE_DISCOVERY
+          expect_option_args(0, args.length)
+          []
+        when :OPTION_LOG_CB, LIBUSB::OPTION_LOG_CB
+          expect_option_args(1, args.length)
+          cb_proc = ctx.send(:wrap_log_cb, args[0], LOG_CB_CONTEXT)
+          [:libusb_log_cb, cb_proc]
+        else
+          raise ArgumentError, "unknown option #{option.inspect}"
+      end
     end
-  else
-    def self.has_capability?(capability)
-      false
+
+    if Call.respond_to?(:libusb_set_option)
+      # Set an default option in the libusb library.
+      #
+      # Use this function to configure a specific option within the library.
+      # See {Call::Options option list}.
+      #
+      # Some options require one or more arguments to be provided.
+      # Consult each option's documentation for specific requirements.
+      #
+      # The option will be added to a list of default options that will be applied to all subsequently created contexts.
+      #
+      # Available since libusb-1.0.22, LIBUSB_API_VERSION >= 0x01000106
+      #
+      # @param [Symbol, Fixnum] option
+      # @param args  Zero or more arguments depending on +option+
+      #
+      # Available since libusb-1.0.22
+      def set_option(option, *args)
+        ffi_args = option_args_to_ffi(option, args, self)
+        res = Call.libusb_set_option(nil, option, *ffi_args)
+        LIBUSB.raise_error res, "in libusb_set_option" if res<0
+      end
+
+      # Convenience function to set default options in the libusb library.
+      #
+      # Use this function to configure any number of options within the library.
+      # It takes a Hash the same way as given to {Context.initialize}.
+      # See also {Call::Options option list}.
+      #
+      # Available since libusb-1.0.22, LIBUSB_API_VERSION >= 0x01000106
+      #
+      # @param [Hash{Call::Options => Object}] options   Option hash
+      # @see set_option
+      def set_options(options={})
+        options.each do |k, v|
+          set_option(k, *Array(v))
+        end
+      end
     end
   end
 end

data/libusb.gemspec

@@ -22,11 +22,7 @@ Gem::Specification.new do |s|
   s.extensions    = ['ext/extconf.rb']
   s.metadata["yard.run"] = "yri"
 
-  s.required_ruby_version = Gem::Requirement.new(">= 1.9.3")
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
   s.add_runtime_dependency 'ffi', '~> 1.0'
   s.add_runtime_dependency 'mini_portile2', LIBUSB::MINI_PORTILE_VERSION
-  s.add_development_dependency 'rake-compiler', '~> 1.0'
-  s.add_development_dependency 'rake-compiler-dock', '~> 0.2'
-  s.add_development_dependency 'bundler', '~> 1.0'
-  s.add_development_dependency 'yard', '~> 0.6'
 end

data/test/test_libusb_bos.rb

@@ -53,6 +53,23 @@ class TestLibusbBos < Minitest::Test
                 :BT_USB_2_0_EXTENSION,
                 :BT_SS_USB_DEVICE_CAPABILITY,
                 :BT_CONTAINER_ID,
+                :BT_WIRELESS_USB_DEVICE_CAPABILITY,
+                :BT_USB_2_0_EXTENSION,
+                :BT_SS_USB_DEVICE_CAPABILITY,
+                :BT_CONTAINER_ID,
+                :BT_PLATFORM_DESCRIPTOR,
+                :BT_POWER_DELIVERY_CAPABILITY,
+                :BT_BATTERY_INFO_CAPABILITY,
+                :BT_PD_CONSUMER_PORT_CAPABILITY,
+                :BT_PD_PROVIDER_PORT_CAPABILITY,
+                :BT_SUPERSPEED_PLUS,
+                :BT_PRECISION_TIME_MEASUREMENT,
+                :BT_Wireless_USB_Ext,
+                :BT_BILLBOARD,
+                :BT_AUTHENTICATION,
+                :BT_BILLBOARD_EX,
+                :BT_CONFIGURATION_SUMMARY,
+                :BT_FWStatus_Capability,
               ], :include?, cap_type
           end
 
@@ -90,6 +107,11 @@ class TestLibusbBos < Minitest::Test
                 assert_operator 0, :<=, cap.bReserved
                 assert_operator 16, :==, cap.container_id.bytesize, "container_id should be 16 bytes long"
 
+              when Bos::PlatformDescriptor
+                assert_operator 0, :<=, cap.bReserved
+                assert_operator 16, :==, cap.platformCapabilityUUID.bytesize, "container_id should be 16 bytes long"
+                assert_kind_of String, cap.capabilityData
+
               else
                 refute true, "invalid device capability class"
             end

data/test/test_libusb_bulk_stream_transfer.rb

@@ -21,11 +21,18 @@ class TestLibusbBulkStreamTransfer < Minitest::Test
 
   def setup
     c = Context.new
-    begin
-      @dev = c.devices.first.open
-    rescue LIBUSB::ERROR_ACCESS
-      @dev = nil
-      skip "error opening device"
+    c.devices.each do |dev|
+      if [:SPEED_SUPER, :SPEED_SUPER_PLUS].include?(dev.device_speed)
+        dev.endpoints.each do |ep|
+          if ep.transfer_type == :bulk
+            ss = ep.ss_companion
+            if ss.bmAttributes & 0x1f > 0
+              @dev = dev.open
+              break
+            end
+          end
+        end
+      end
     end
   end
 
@@ -34,17 +41,21 @@ class TestLibusbBulkStreamTransfer < Minitest::Test
   end
 
   def test_alloc_streams
-    assert_raises(ERROR_NOT_SUPPORTED, "TODO: test with a OS that supports bulk streams and against a real device") do
-      nr_allocated = @dev.alloc_streams( 2, @dev.device.endpoints )
-    end
+    skip "no device found with bulk stream support" unless @dev
 
-    assert_raises(ERROR_NOT_SUPPORTED) do
-      @dev.free_streams( [0x01,0x82] )
-    end
+    nr_allocated = @dev.alloc_streams( 2, @dev.device.endpoints )
+    assert_equal 2, nr_allocated
+
+    # TODO: test with a OS that supports bulk streams and against a real device
+
+    @dev.free_streams( [0x01,0x82] )
   end
 
   def test_bulk_stream_transfer
-    tr = BulkStreamTransfer.new dev_handle: @dev, stream_id: 123, buffer: ' '*100
+    c = Context.new
+    dev = c.devices.first.open
+    tr = BulkStreamTransfer.new dev_handle: dev, stream_id: 123, buffer: ' '*100
     assert_equal 123, tr.stream_id, "stream_id should match"
+    dev.close
   end
 end

data/test/test_libusb_context.rb

@@ -38,4 +38,51 @@ class TestLibusbContext < Minitest::Test
     @c.debug = 4
     @c.debug = 0
   end
+
+  def test_left_references
+    @test_devs = @c.devices
+    assert_raises(LIBUSB::RemainingReferencesError) do
+      @c.exit
+    end
+    @c = nil
+  end
+
+  def test_double_exit
+    @c.exit
+  end
+
+  def test_log_callback
+    skip "only supported on Linux" unless RUBY_PLATFORM=~/linux/
+    skip "libusb version older than 1.0.27" if Gem::Version.new(LIBUSB.version) < Gem::Version.new("1.0.27")
+
+    LIBUSB.set_options OPTION_LOG_CB: [nil], OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_NONE
+    begin
+      called = Hash.new { |h, k| h[k] = [] }
+      LIBUSB.set_options OPTION_LOG_CB: proc{|*a| called[:global] << a }, OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_DEBUG
+
+      c = LIBUSB::Context.new OPTION_LOG_CB: proc{|*a| called[:ctx1] << a }, OPTION_NO_DEVICE_DISCOVERY: nil
+      c.devices
+      c.set_log_cb(LIBUSB::LOG_CB_CONTEXT){|*a| called[:ctx2] << a }
+      c.devices
+
+      #pp called
+      assert_nil called[:global][0][0]
+      assert_equal :LOG_LEVEL_DEBUG, called[:global][0][1], called[:global][0][2]
+      assert_match(/libusb_init_context/, called[:global].join)
+      assert_match(/no device discovery/, called[:global].join)
+
+      assert_operator called[:ctx1].size, :>, called[:ctx2].size
+      assert_equal c, called[:ctx1][-1][0]
+      assert_equal :LOG_LEVEL_DEBUG, called[:ctx1][-1][1]
+      assert_match(/libusb_get_device_list/, called[:ctx1][-1][2])
+      assert_match(/no device discovery/, called[:ctx1].join)
+
+      assert_equal c, called[:ctx2][-1][0]
+      assert_equal :LOG_LEVEL_DEBUG, called[:ctx2][-1][1]
+      assert_match(/libusb_get_device_list/, called[:ctx2][-1][2])
+
+    ensure
+      LIBUSB.set_options OPTION_LOG_CB: [nil], OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_NONE
+    end
+  end
 end

data/test/test_libusb_descriptors.rb

@@ -119,7 +119,7 @@ class TestLibusbDescriptors < Minitest::Test
 
     usb.devices.each do |dev|
       dev.endpoints.each do |ep|
-        if dev.device_speed == :SPEED_SUPER
+        if [:SPEED_SUPER, :SPEED_SUPER_PLUS].include?(dev.device_speed)
           ss = ep.ss_companion
           assert_match(/SsCompanion/, ss.inspect, "SsCompanion#inspect should work")
 
@@ -172,14 +172,19 @@ class TestLibusbDescriptors < Minitest::Test
   def test_device_filter_hubs
     devs1 = []
     usb.devices.each do |dev|
-      dev.settings.each do |if_desc|
-        if if_desc.bInterfaceClass == CLASS_HUB
-          devs1 << dev
+      if dev.bDeviceClass==CLASS_PER_INTERFACE
+        dev.settings.each do |if_desc|
+          if if_desc.bInterfaceClass==CLASS_HUB
+            devs1 << dev
+          end
         end
+      else
+        devs1 << dev if dev.bDeviceClass == CLASS_HUB
       end
     end
 
     devs2 = usb.devices( bClass: CLASS_HUB )
+
     assert_equal devs1.sort, devs2.sort, "devices and devices with filter should deliver the same device"
   end
 
@@ -189,11 +194,11 @@ class TestLibusbDescriptors < Minitest::Test
       if ep
         assert_operator dev.max_packet_size(ep), :>, 0, "#{dev.inspect} should have a usable packet size"
         assert_operator dev.max_packet_size(ep.bEndpointAddress), :>, 0, "#{dev.inspect} should have a usable packet size"
-        assert_operator dev.max_iso_packet_size(ep), :>, 0, "#{dev.inspect} should have a usable iso packet size"
-        assert_operator dev.max_iso_packet_size(ep.bEndpointAddress), :>, 0, "#{dev.inspect} should have a usable iso packet size"
+        assert_operator dev.max_iso_packet_size(ep), :>=, 0, "#{dev.inspect} should have a usable iso packet size"
+        assert_operator dev.max_iso_packet_size(ep.bEndpointAddress), :>=, 0, "#{dev.inspect} should have a usable iso packet size"
         assert_operator dev.bus_number, :>=, 0, "#{dev.inspect} should have a bus_number"
         assert_operator dev.device_address, :>=, 0, "#{dev.inspect} should have a device_address"
-        assert_operator([:SPEED_UNKNOWN, :SPEED_LOW, :SPEED_FULL, :SPEED_HIGH, :SPEED_SUPER], :include?, dev.device_speed, "#{dev.inspect} should have a device_speed")
+        assert_operator([:SPEED_UNKNOWN, :SPEED_LOW, :SPEED_FULL, :SPEED_HIGH, :SPEED_SUPER, :SPEED_SUPER_PLUS], :include?, dev.device_speed, "#{dev.inspect} should have a device_speed")
         path = dev.port_numbers
         assert_kind_of Array, path, "#{dev.inspect} should have port_numbers"
         path = dev.port_path
@@ -201,12 +206,40 @@ class TestLibusbDescriptors < Minitest::Test
         path.each do |port|
           assert_operator port, :>, 0, "#{dev.inspect} should have proper port_path entries"
         end
-        assert_equal path[-1], dev.port_number, "#{dev.inspect} should have a port number out of the port_path"
-        if parent=dev.parent
-          assert_kind_of Device, parent, "#{dev.inspect} should have a parent"
-          assert_equal path[-2], parent.port_number, "#{dev.inspect} should have a parent port number out of the port_path"
+        if path.empty?
+          assert_nil dev.port_number
+        else
+          assert_equal path[-1], dev.port_number, "#{dev.inspect} should have a port number out of the port_path"
+          if parent=dev.parent
+            assert_kind_of Device, parent, "#{dev.inspect} should have a parent"
+            assert_equal path[-2], parent.port_number, "#{dev.inspect} should have a parent port number out of the port_path" if parent.port_number
+          end
         end
       end
     end
   end
+
+  def test_wrap_sys_device
+    skip unless RUBY_PLATFORM =~ /linux/
+    d = usb.devices[0]
+    File.open(format("/dev/bus/usb/%03d/%03d", d.bus_number, d.device_address), "w+") do |io|
+      devh = usb.wrap_sys_device(io)
+      devh.kernel_driver_active?(0)
+      devh.close
+
+      usb.wrap_sys_device(io) do |devh|
+        devh.kernel_driver_active?(0)
+      end
+    end
+  end
+
+  def test_wrap_sys_device_failure
+    skip unless RUBY_PLATFORM =~ /linux/
+    d = usb.devices[0]
+    assert_raises(LIBUSB::ERROR_OTHER) do
+      File.open(format("/dev/bus/usb/%03d/%03d", d.bus_number, d.device_address), "r") do |io|
+        usb.wrap_sys_device(io).kernel_driver_active?(0)
+      end
+    end
+  end
 end

data/test/test_libusb_gc.rb

@@ -34,4 +34,19 @@ class TestLibusbGc < Minitest::Test
     GC.start
     assert_equal ps, ep.wMaxPacketSize, "GC should not free EndpointDescriptor"
   end
+
+  def test_log_cb
+    LIBUSB.set_options OPTION_LOG_CB: proc{}, OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_DEBUG
+
+    c = LIBUSB::Context.new OPTION_LOG_CB: proc{}, OPTION_NO_DEVICE_DISCOVERY: nil
+    GC.start
+    c.devices
+    c.set_log_cb(LIBUSB::LOG_CB_CONTEXT){}
+    c.devices
+    GC.start
+    c.devices
+
+  ensure
+    LIBUSB.set_options OPTION_LOG_CB: [nil], OPTION_LOG_LEVEL: LIBUSB::LOG_LEVEL_NONE
+  end
 end

data/test/test_libusb_hotplug.rb

@@ -26,7 +26,9 @@ class TestLibusbHotplug < Minitest::Test
   end
 
   def teardown
-    @ctx.exit
+    # No need to release the LIBUSB::Context any longer.
+    # It is cleaned up by the GC.
+    # @ctx.exit
   end
 
   def test_enumerate

data/test/test_libusb_iso_transfer.rb

@@ -47,4 +47,10 @@ class TestLibusbIsoTransfer < Minitest::Test
       tr.submit!
     end
   end
+
+  def test_max_alt_packet_size
+    d = Context.new.devices[0]
+    size = d.max_alt_packet_size d.interfaces[0], d.settings[0], d.endpoints[0]
+    assert_operator 0, :<=, size
+  end
 end

data/test/test_libusb_mass_storage.rb

@@ -61,7 +61,7 @@ class TestLibusbMassStorage < Minitest::Test
     dev.close if dev
   end
 
-  def do_transfer(method, args)
+  def do_transfer(method, **args)
     if @asynchron
       stop = false
       transfer = dev.send(method, args) do |tr|
@@ -78,14 +78,14 @@ class TestLibusbMassStorage < Minitest::Test
       end
       transfer.result
     else
-      dev.send(method, args)
+      dev.send(method, **args)
     end
   end
-  def control_transfer(args)
-    do_transfer(:control_transfer, args)
+  def control_transfer(**args)
+    do_transfer(:control_transfer, **args)
   end
-  def bulk_transfer(args)
-    do_transfer(:bulk_transfer, args)
+  def bulk_transfer(**args)
+    do_transfer(:bulk_transfer, **args)
   end
 
   def send_mass_storage_command(cdb, data_length, direction=ENDPOINT_IN)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libusb
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.7.1
 platform: x64-mingw32
 authors:
 - Lars Kanis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-05 00:00:00.000000000 Z
+date: 2024-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,62 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler-dock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
 description: LIBUSB is a Ruby binding that gives Ruby programmers access to arbitrary
   USB devices
 email:
@@ -88,6 +32,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".appveyor.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".travis.yml"
 - ".yardopts"
@@ -96,7 +42,6 @@ files:
 - History.md
 - README.md
 - Rakefile
-- appveyor.yml
 - lib/libusb-1.0.dll
 - lib/libusb.rb
 - lib/libusb/bos.rb
@@ -105,6 +50,7 @@ files:
 - lib/libusb/configuration.rb
 - lib/libusb/constants.rb
 - lib/libusb/context.rb
+- lib/libusb/context_reference.rb
 - lib/libusb/dependencies.rb
 - lib/libusb/dev_handle.rb
 - lib/libusb/device.rb
@@ -152,15 +98,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: Access USB devices from Ruby via libusb-1.0