hidaping 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c38b9b9d15828de26fea00975aa9744b1ab4351cc52bba779c3daf257b987efc
+  data.tar.gz: d65edf49a8fe4b072f3e68ad038d31d4a349c4a4331f2f38d24cfc20157780c4
+SHA512:
+  metadata.gz: 7212e791d8fcc018e825b6ed54a2add5c8c2096e7aea2b8ce9375379a3710f25d8268d973e67b1fa691d928c5cd42e878580f40745fbeeac39890b07ddc8f5ea
+  data.tar.gz: c8a7bf89640c6962fed10d48747cc3d024bc285889afe83fdfe2ea1221dd053265a4fdc70ba9b863eed961172cf557f2cb4e84e4ee7c900cb4b73e56b3076d90

data/.clang-format

@@ -0,0 +1,5 @@
+BasedOnStyle: LLVM     
+
+ColumnLimit: 100
+IndentWidth: 4
+

data/.github/workflows/gem-push.yml

@@ -0,0 +1,50 @@
+name: Ruby Gem
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pages: write
+      id-token: write
+
+    steps:
+      - name: Clone
+        uses: actions/checkout@v4
+      - name: Set up Ruby 3.4.5
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.4.5
+      - name: Build
+        run: |
+          bundle install
+          bundle exec rake gem
+          
+          mkdir -p ~/.gem
+          cat <<AAA > ~/.gem/.mirrorrc
+          ---
+          - from: https://repy.github.io/hidaping
+            to: /home/runner/gemrepos
+          AAA
+          mkdir -p /home/runner/gemrepos/gems
+          gem install rubygems-mirror
+          gem mirror
+          
+          cp ./pkg/hidaping-*.gem /home/runner/gemrepos/gems/
+          cd /home/runner/gemrepos
+          gem generate_index
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: /home/runner/gemrepos
+      - name: Deploy to GitHub Pages
+        uses: actions/deploy-pages@v4

data/.github/workflows/test.yml

@@ -0,0 +1,53 @@
+name: Test on All OS
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: 
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+
+    steps:
+      - name: Clone
+        uses: actions/checkout@v4
+      - name: Set up Ruby 3.4.5
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.4.5
+
+      - name: Run tests (Ubuntu)
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt install -y libhidapi-dev
+          gem install bundler
+          bundle install
+          bundle exec rake compile
+          bundle exec ruby test/test.rb
+
+      - name: Run tests (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          pacman --noconfirm -S mingw-w64-ucrt-x86_64-hidapi
+          gem install bundler
+          bundle install
+          bundle exec rake compile
+          bundle exec ruby test/test.rb
+
+      - name: Run tests (macOS)
+        if: runner.os == 'macOS'
+        run: |
+          brew install hidapi
+          gem install bundler
+          bundle install
+          bundle exec rake compile
+          sudo bundle exec ruby test/test.rb

data/.ruby-version

@@ -0,0 +1 @@
+3.4.5

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+=== 1.1.0 / 2024-05-24
+
+* Forked from https://github.com/tenderlove/myhidapi and updated project metadata.
+* Improved the build process to use `pkg-config` for locating the `hidapi` library. This simplifies installation on systems where `hidapi` is installed via a package manager (e.g., Homebrew, apt).
+
+=== 1.0.0 / 2019-02-15
+
+* 1 major enhancement
+* Birthday!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Repy
+Copyright (c) 2019 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# HIDAPING
+
+Next generation HIDAPI wrapper for Ruby
+
+## DESCRIPTION
+
+This is a small wrapper around HIDAPI.
+I couldn't get other HIDAPI wrappers to work, so I wrote this one.
+I'm using it to communicate with my keyboard, so it really only supports enough of the HIDAPI to do that.
+
+## DESCRIPTION
+
+* https://github.com/Repy/hidaping
+
+This gem is a fork from the original work by Aaron Patterson ([@tenderlove](https://github.com/tenderlove)).
+
+* Original Repository: https://github.com/tenderlove/myhidapi
+
+## SUPPORTS
+
+This gem works on the following platforms, leveraging the capabilities of the underlying HIDAPI library.
+
+*   **Platforms**:
+    *   Windows
+    *   macOS
+    *   Linux
+
+*   **Device Types**:
+    *   USB
+    *   Bluetooth
+
+## FEATURES/PROBLEMS
+
+* Incomplete
+* No tests
+* Seems to work (for me)
+
+## SYNOPSIS
+
+```ruby
+require 'hidaping'
+
+devices = HIDAPING.enumerate(0x0, 0x0)
+
+for d in devices
+    printf("0x%04x, 0x%04x, %s\n", d.vendor_id, d.product_id, d.product_string)
+end
+
+handle = HIDAPING.open(0x045e, 0x028e)
+
+while true
+    report_raw = handle.read_timeout(64, 500)
+    data = report_raw.unpack("vvvvvb*")
+    p data
+end
+```
+
+## REQUIREMENTS
+
+This depends on **hidapi**.
+
+## INSTALL
+
+First, install the **hidapi** library. Here are instructions for common platforms:
+
+*   **Windows (using RubyInstaller with Devkit)**
+
+    ```sh
+    ridk exec pacman -S mingw-w64-ucrt-x86_64-hidapi
+    ```
+
+*   **macOS (using Homebrew)**
+
+    ```sh
+    brew install hidapi
+    ```
+
+*   **Ubuntu / Debian**
+
+    ```sh
+    sudo apt update
+    sudo apt install libhidapi-dev
+    ```
+
+Once `hidapi` is installed, you can install this gem:
+
+```sh
+gem install hidaping
+```
+
+## LICENSE
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.md).

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require 'rake/packagetask'
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load("hidaping.gemspec")
+
+Rake::ExtensionTask.new("hidaping", GEMSPEC) do |ext|
+  ext.lib_dir = "lib/hidaping"
+end
+
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+end
+
+task default: %i[clobber compile]

data/ext/hidaping/common.h

@@ -0,0 +1,17 @@
+#ifndef MY_HIDAPI_COMMON_H
+#define MY_HIDAPI_COMMON_H
+
+#include "extconf.h"
+
+#if defined(HAVE_HIDAPI_H)
+#include <hidapi.h>
+#elif defined(HAVE_HIDAPI_HIDAPI_H)
+#include <hidapi/hidapi.h>
+#else
+#error "No suitable header found"
+#endif
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#endif // MY_HIDAPI_COMMON_H

data/ext/hidaping/extconf.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+dir_config("hidapi")
+pkg_config('hidapi')
+
+if have_library('hidapi')
+    libname = 'hidapi'
+elsif have_library('hidapi-hidraw')
+    libname = 'hidapi-hidraw'
+elsif have_library('hidapi-libusb')
+    libname = 'hidapi-libusb'
+else
+  abort 'you must have "libhidapi".'
+end
+
+if have_header('hidapi/hidapi.h')
+    header = 'hidapi/hidapi.h'
+elsif have_header('hidapi.h')
+    header = 'hidapi.h'
+else
+  abort 'you must have "hidapi.h".'
+end
+
+create_header
+create_makefile("hidaping/hidaping")

data/ext/hidaping/hidaping.c

@@ -0,0 +1,57 @@
+#include "hidaping.h"
+#include "hidaping_device.h"
+#include "hidaping_util.h"
+
+VALUE mHIDAPING;
+
+static VALUE enumerate(VALUE mod, VALUE vendor_id, VALUE product_id) {
+    VALUE devices;
+    struct hid_device_info *devs, *cur_dev;
+
+    VALUE device_info_class = rb_path2class("HIDAPING::DeviceInfo");
+
+    devices = rb_ary_new();
+    devs = hid_enumerate(NUM2USHORT(vendor_id), NUM2USHORT(product_id));
+    cur_dev = devs;
+    while (cur_dev) {
+        VALUE args[] = {INT2NUM(cur_dev->vendor_id),
+                        INT2NUM(cur_dev->product_id),
+                        rb_str_new2(cur_dev->path),
+                        hidaping_wcstombs(cur_dev->serial_number),
+                        hidaping_wcstombs(cur_dev->manufacturer_string),
+                        hidaping_wcstombs(cur_dev->product_string),
+                        INT2NUM(cur_dev->usage),
+                        INT2NUM(cur_dev->interface_number)};
+        rb_ary_push(devices, rb_class_new_instance(8, args, device_info_class));
+        cur_dev = cur_dev->next;
+    }
+    hid_free_enumeration(devs);
+
+    return devices;
+}
+
+static VALUE rb_hid_open(VALUE mod, VALUE vid, VALUE pid) {
+    hid_device *handle = hid_open(NUM2USHORT(vid), NUM2USHORT(pid), NULL);
+    if (handle) {
+        return create_hidaping_handle(handle);
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE rb_hid_open_path(VALUE mod, VALUE path) {
+    hid_device *handle = hid_open_path(StringValueCStr(path));
+    if (handle) {
+        return create_hidaping_handle(handle);
+    } else {
+        return Qfalse;
+    }
+}
+
+extern void Init_hidaping(void) {
+    mHIDAPING = rb_define_module("HIDAPING");
+    rb_define_singleton_method(mHIDAPING, "enumerate", enumerate, 2);
+    rb_define_singleton_method(mHIDAPING, "open", rb_hid_open, 2);
+    rb_define_singleton_method(mHIDAPING, "open_path", rb_hid_open_path, 1);
+    Init_hidaping_device(mHIDAPING);
+}

data/ext/hidaping/hidaping.h

@@ -0,0 +1,6 @@
+#ifndef MY_HIDAPI_H
+#define MY_HIDAPI_H
+
+#include "common.h"
+
+#endif // MY_HIDAPI_H

data/ext/hidaping/hidaping_device.c

@@ -0,0 +1,159 @@
+#include "hidaping_device.h"
+#include "hidaping.h"
+#include "hidaping_util.h"
+
+#define BUF_SIZE 4096
+
+VALUE cHIDAPINGHandle;
+
+static void dealloc(void *ptr) {
+    hid_device *handle = (hid_device *)ptr;
+    hid_close(handle);
+}
+
+static const rb_data_type_t hidaping_handle_type = {
+    "HIDAPING/Handle",
+    {
+        0,
+        dealloc,
+        0,
+    },
+    0,
+    0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+VALUE create_hidaping_handle(hid_device *handle) {
+    return TypedData_Wrap_Struct(cHIDAPINGHandle, &hidaping_handle_type, handle);
+}
+
+static VALUE rb_hid_write(VALUE self, VALUE str) {
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    int written = hid_write(handle, (unsigned char *)StringValuePtr(str), RSTRING_LEN(str));
+
+    if (written >= 0) {
+        return INT2NUM(written);
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE rb_hid_set_nonblocking(VALUE self, VALUE val) {
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    if (!hid_set_nonblocking(handle, NUM2INT(val))) {
+        return Qtrue;
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE rb_hid_read(VALUE self, VALUE size) {
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    unsigned char *buf = xcalloc(NUM2SIZET(size), sizeof(unsigned char));
+    int read = hid_read(handle, buf, NUM2SIZET(size));
+
+    VALUE ret;
+    if (read > 0) {
+        ret = rb_str_new((char *)buf, read);
+    } else {
+        ret = Qnil;
+    }
+
+    xfree(buf);
+    return ret;
+}
+
+static VALUE rb_hid_read_timeout(VALUE self, VALUE size, VALUE timeout_ms) {
+    hid_device *handle;
+    unsigned char *buf;
+    int read;
+    VALUE ret;
+
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    buf = xcalloc(NUM2SIZET(size), sizeof(unsigned char));
+
+    read = hid_read_timeout(handle, buf, NUM2SIZET(size), NUM2INT(timeout_ms));
+
+    if (read > 0) {
+        ret = rb_str_new((char *)buf, read);
+    } else {
+        ret = Qnil;
+    }
+    xfree(buf);
+    return ret;
+}
+
+static VALUE rb_hid_send_feature_report(VALUE self, VALUE str) {
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    int written =
+        hid_send_feature_report(handle, (unsigned char *)StringValuePtr(str), RSTRING_LEN(str));
+
+    if (written >= 0) {
+        return INT2NUM(written);
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE rb_hid_get_feature_report(VALUE self, VALUE report_id, VALUE size) {
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    int buf_size = NUM2SIZET(size);
+    unsigned char *buf = xcalloc(buf_size, sizeof(unsigned char));
+    int read = hid_get_feature_report(handle, buf, buf_size);
+
+    VALUE ret;
+    if (read > 0) {
+        ret = rb_str_new((char *)buf, read);
+    } else {
+        ret = Qnil;
+    }
+
+    xfree(buf);
+    return ret;
+}
+
+static VALUE rb_manufacturer(VALUE self) {
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    wchar_t buffer[BUF_SIZE];
+    hid_get_manufacturer_string(handle, buffer, BUF_SIZE);
+
+    return hidaping_wcstombs(buffer);
+}
+
+static VALUE rb_product(VALUE self) {
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &hidaping_handle_type, handle);
+
+    wchar_t buffer[BUF_SIZE];
+    hid_get_product_string(handle, buffer, BUF_SIZE);
+
+    return hidaping_wcstombs(buffer);
+}
+
+void Init_hidaping_device(VALUE mHIDAPING) {
+    cHIDAPINGHandle = rb_define_class_under(mHIDAPING, "Handle", rb_cObject);
+    rb_undef_alloc_func(cHIDAPINGHandle);
+    rb_define_method(cHIDAPINGHandle, "write", rb_hid_write, 1);
+    rb_define_method(cHIDAPINGHandle, "read", rb_hid_read, 1);
+    rb_define_method(cHIDAPINGHandle, "read_timeout", rb_hid_read_timeout, 2);
+    rb_define_method(cHIDAPINGHandle, "set_nonblocking", rb_hid_set_nonblocking, 1);
+    rb_define_method(cHIDAPINGHandle, "send_feature_report", rb_hid_send_feature_report, 1);
+    rb_define_method(cHIDAPINGHandle, "get_feature_report", rb_hid_get_feature_report, 2);
+    rb_define_method(cHIDAPINGHandle, "manufacturer", rb_manufacturer, 0);
+    rb_define_method(cHIDAPINGHandle, "product", rb_product, 0);
+}

data/ext/hidaping/hidaping_device.h

@@ -0,0 +1,9 @@
+#ifndef MY_HIDAPI_DEVICE_H
+#define MY_HIDAPI_DEVICE_H
+
+#include "common.h"
+
+VALUE create_hidaping_handle(hid_device *handle);
+void Init_hidaping_device(VALUE mHIDAPING);
+
+#endif // MY_HIDAPI_DEVICE_H

data/ext/hidaping/hidaping_util.h

@@ -0,0 +1,19 @@
+#ifndef MY_HIDAPI_UTIL_H
+#define MY_HIDAPI_UTIL_H
+
+#include "common.h"
+
+#define BUF_SIZE 4096
+
+static VALUE hidaping_wcstombs(wchar_t *str) {
+    char buf[BUF_SIZE];
+    int len;
+    len = wcstombs(buf, str, BUF_SIZE);
+    if (len > 0) {
+        return rb_str_new(buf, len);
+    } else {
+        return Qnil;
+    }
+}
+
+#endif // MY_HIDAPI_UTIL_H

data/lib/hidaping/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HIDAPING
+  VERSION = '1.1.0'
+end

data/lib/hidaping.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "hidaping/hidaping.so"
+
+module HIDAPING
+
+  class DeviceInfo
+    attr_reader :vendor_id, :product_id, :path, :serial_number, :manufacturer_string, :product_string, :usage, :interface_number
+
+    def initialize vendor_id, product_id, path, serial_number, manufacturer_string, product_string, usage, interface_number
+      @vendor_id           = vendor_id
+      @product_id          = product_id
+      @path                = path
+      @serial_number       = serial_number
+      @manufacturer_string = manufacturer_string
+      @product_string      = product_string
+      @usage               = usage
+      @interface_number    = interface_number
+    end
+
+    def open
+      HIDAPING.open vendor_id, product_id
+    end
+  end
+
+end

data/sample/kbprog.rb

@@ -0,0 +1,190 @@
+require 'hidaping'
+require 'optparse'
+
+class TeeloKB
+  class Error < StandardError; end
+  class CouldNotReadError < Error; end
+  class KeyboardNotFoundError < Error; end
+
+  COMMAND_VERSIONS = { 1 => {} }
+
+  %i{
+    version
+    rgblight_enable
+    rgblight_disable
+    rgblight_toggle
+    rgblight_mode
+    rgblight_sethsv
+    rgblight_get_mode
+    rgblight_get_hue
+    rgblight_get_sat
+    rgblight_get_val
+  }.each_with_index do |command, index|
+    COMMAND_VERSIONS[1][command] = index + 1
+  end
+
+  def self.find
+    HIDAPING.enumerate(0x0, 0x0).find { |dev| dev.product_string == "ErgoDox EZ" }
+  end
+
+  def self.open
+    dev = self.find
+
+    retries = 0
+    handle = dev.open
+    while !handle
+      retries += 1
+      raise KeyboardNotFoundError, "Couldn't find keyboard" if retries > 10
+      handle = dev.open
+    end
+
+    new handle
+  end
+
+  def initialize handle
+    @handle = handle
+    @version = protocol_version
+  end
+
+  def protocol_version
+    write [0x0, 0x1]
+    read(2).inject(:+)
+  end
+
+  def solid
+    rgblight_mode 0x1
+  end
+
+  def enable
+    write [0x0, _(:rgblight_enable)]
+    read 10
+  end
+
+  def disable
+    write [0x0, _(:rgblight_disable)]
+    read 10
+  end
+
+  def toggle
+    write [0x0, _(:rgblight_toggle)]
+    read 10
+  end
+
+  def mode
+    write [0x0, _(:rgblight_get_mode)]
+    read(2).last
+  end
+
+  def rainbow style = 0x6
+    rgblight_mode style
+  end
+
+  def rgblight_mode value
+    write [0x0, _(:rgblight_mode), value & 0xFF]
+    read 10
+  end
+  alias :mode= :rgblight_mode
+
+  def rgblight_sethsv h, s, v
+    write([0x0, _(:rgblight_sethsv)] + [(h >> 8) & 0xFF, h & 0xFF, s & 0xFF, v & 0xFF])
+    read 10
+  end
+  alias :sethsv :rgblight_sethsv
+
+  def setrgb r, g, b
+    sethsv *rgb2hsv(r, g, b)
+  end
+
+  def hue
+    write [0x0, _(:rgblight_get_hue)]
+    _, upper, lower = read 3
+    (upper << 8) | lower
+  end
+
+  def saturation
+    write [0x0, _(:rgblight_get_sat)]
+    read(2)[1]
+  end
+
+  def value
+    write [0x0, _(:rgblight_get_val)]
+    read(2)[1]
+  end
+
+  def hsv
+    [hue, saturation, value]
+  end
+
+  private
+
+  def rgb2hsv r, g, b
+    v     = [r, g, b].max
+    delta = v - [r, g, b].min
+
+    s = v == 0 ? 0 : (delta / v.to_f)
+    h = delta == 0 ? 0 : (case v
+    when r then ((g - b) / delta) % 6
+    when g then ((b - r) / delta) + 2
+    when b then ((r - g) / delta) + 4
+    end) * 60
+
+    [h.round, (s * 255).round, v]
+  end
+
+  def write buf
+    loop do
+      break if @handle.write buf.pack('C*')
+    end
+  end
+
+  def read size
+    buf = @handle.read_timeout size, 300 # 300 ms timeout
+    if buf
+      buf.unpack('C*')
+    else
+      # Unfortunately, this seems to happen frequently.
+      raise CouldNotReadError, "could not read from device"
+    end
+  end
+
+  def _ command
+    COMMAND_VERSIONS.fetch(@version).fetch(command)
+  end
+end
+
+commands = []
+responses = []
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: kbprog.rb [options]"
+
+  opts.on("--hsv=[HSV]", "Set or get HSV (comma separated)") do |v|
+    if v
+      commands << lambda { |kb| kb.sethsv(*v.split(",").map(&:to_i)) }
+    else
+      commands << lambda { |kb| responses << { hsv: kb.hsv } }
+    end
+  end
+  opts.on("--mode=[HSV]", "Set or get mode") do |v|
+    if v
+      commands << lambda { |kb| kb.mode = v.to_i }
+    else
+      commands << lambda { |kb| responses << { mode: kb.mode } }
+    end
+  end
+end.parse!
+
+kb = TeeloKB.open
+commands.each { |cmd| cmd.call kb }
+responses.each do |res|
+  p res
+end
+
+#p ez.mode
+#ez.mode = 5
+#ez.sethsv 300, 250, 255
+#p ez.hsv
+
+#rescue TeeloKB::Error => e
+#  exec "ruby --disable-gems -I lib:test #{__FILE__}"
+#end

data/sample/set_hsv.rb

@@ -0,0 +1,21 @@
+require 'hidaping'
+
+def try_block times
+  times.times { x = yield; return x if x }
+  raise "Couldn't do it"
+end
+
+dev = HIDAPING.enumerate(0x0, 0x0).find { |dev| dev.product_string == "ErgoDox EZ" }
+
+handle = try_block(10) { dev.open }
+p handle
+
+h = 0    # 0x0 to 0x168 (which is 360 base 10)
+s = 0xFF # 0x0 to 0xFF
+v = 0xFF # 0x0 to 0xFF
+
+try_block(10) do
+  handle.write [0x0, 0x6, (h >> 8) & 0xFF, h & 0xFF, s, v].pack('C*')
+end
+
+handle.read_timeout 10, 300 # 300 ms timeout

data/sig/myhidapi.rbs

@@ -0,0 +1,4 @@
+module HIDAPING
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test/joycon.rb

@@ -0,0 +1,16 @@
+require 'hidaping'
+
+devices = HIDAPING.enumerate(0x0, 0x0)
+
+for d in devices
+    printf("0x%04x, 0x%04x, %s\n", d.vendor_id, d.product_id, d.product_string)
+end
+
+handle = HIDAPING.open(0x057e, 0x2007)
+handle.send_feature_report("\x01\x48\x00\x01\x40\x40\x00\x01\x40\x40\x00")
+
+while true
+    report_raw = handle.read_timeout(64, 500)
+    data = report_raw.unpack("a17va*")
+    p data[1]
+end

data/test/test.rb

@@ -0,0 +1,14 @@
+require 'hidaping'
+
+devices = HIDAPING.enumerate(0x0, 0x0)
+
+for d in devices
+    printf("0x%04x, 0x%04x, %s\n", d.vendor_id, d.product_id, d.product_string)
+end
+
+if devices.length > 0
+    handle = devices[0].open()
+
+    report_raw = handle.read_timeout(64, 500)
+    p report_raw
+end

data/test/test_myhidapi.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'hidaping'
+
+class TestHIDAPING < MiniTest::Test
+  def test_it_works
+    devices = HIDAPING.enumerate 0x0, 0x0
+    dev = devices.find { |dev| dev.product_string == "ErgoDox EZ" }
+
+    handle = dev.open
+
+    while !handle
+      p "retry"
+      handle = dev.open
+    end
+
+    p handle
+
+    buf = [0x0, 0x3, 35]
+    loop do
+      break if handle.write buf.pack('C*')
+    end
+    puts "done writing"
+
+    buf = handle.read_timeout 1, 500
+    p buf
+  end
+
+  def test_can_enumerate_by_ids
+    devices = HIDAPING.enumerate(0xfeed, 0x1307)
+
+    refute_predicate devices, :empty?
+  end
+end

data/test/xbox360.rb

@@ -0,0 +1,15 @@
+require 'hidaping'
+
+devices = HIDAPING.enumerate(0x0, 0x0)
+
+for d in devices
+    printf("0x%04x, 0x%04x, %s\n", d.vendor_id, d.product_id, d.product_string)
+end
+
+handle = HIDAPING.open(0x045e, 0x028e)
+
+while true
+    report_raw = handle.read_timeout(64, 500)
+    data = report_raw.unpack("vvvvvSb*")
+    p data
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: hidaping
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Repy
+- Aaron Patterson
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  This is a small wrapper around HIDAPI.
+  I couldn't get other HIDAPI wrappers to work, so I wrote this one.
+  I'm using it to communicate with my keyboard, so it really only supports enough of the HIDAPI to do that.
+
+  This gem is a fork from the original work by Aaron Patterson (@tenderlove).
+email:
+- gamecube02+git@gmail.com
+- tenderlove@ruby-lang.org
+executables: []
+extensions:
+- ext/hidaping/extconf.rb
+extra_rdoc_files: []
+files:
+- ".clang-format"
+- ".github/workflows/gem-push.yml"
+- ".github/workflows/test.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/hidaping/common.h
+- ext/hidaping/extconf.rb
+- ext/hidaping/hidaping.c
+- ext/hidaping/hidaping.h
+- ext/hidaping/hidaping_device.c
+- ext/hidaping/hidaping_device.h
+- ext/hidaping/hidaping_util.h
+- lib/hidaping.rb
+- lib/hidaping/version.rb
+- sample/kbprog.rb
+- sample/set_hsv.rb
+- sig/myhidapi.rbs
+- test/joycon.rb
+- test/test.rb
+- test/test_myhidapi.rb
+- test/xbox360.rb
+homepage: https://github.com/Repy/hidaping
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Repy/hidaping
+  source_code_uri: https://github.com/Repy/hidaping
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: A wrapper around hidapi for Ruby
+test_files: []