feat(selector): add multi-device selector

Author: haithium

src/evdev/selector.lua

@@ -0,0 +1,124 @@
+---@diagnostic disable: missing-fields, inject-field
+
+local evdev = require "evdev"
+
+local validate = evdev._util.validate
+local tbl_find = evdev._util.tbl_find
+local is_device = evdev.device.is_device
+local poll_devices = evdev._core.poll_devices
+
+---@type evdev.Selector
+local Selector = {}
+Selector.__index = Selector
+
+local function validate_device(lbl, dev)
+  if not is_device(dev) then
+    error(lbl .. ": (evdev.Device expected)", 3)
+  end
+  return dev
+end
+
+---@param devs evdev.Device[]
+local function validate_handles(devs)
+  for i, dev in ipairs(devs) do
+    local core = type(dev) == "table" and rawget(dev, "_core")
+    if not core then
+      return nil, "devices[" .. i .. "]: device is closed"
+    end
+  end
+  return true
+end
+
+function Selector:add(dev)
+  validate_device("device", dev)
+  if not tbl_find(self._devices, dev) then
+    self._devices[#self._devices + 1] = dev
+    self._handles[#self._handles + 1] = rawget(dev, "_core")
+  end
+  return self
+end
+
+function Selector:remove(dev)
+  validate_device("device", dev)
+  local _, i = tbl_find(self._devices, dev)
+  if i then
+    table.remove(self._devices, i)
+    table.remove(self._handles, i)
+  end
+  return self
+end
+
+function Selector:clear()
+  self._devices = {}
+  self._handles = {}
+  return self
+end
+
+function Selector:poll()
+  local devs = self._devices
+  local ok, err = validate_handles(devs)
+  if not ok then
+    return nil, err
+  end
+
+  local ready_indexes, poll_err = poll_devices(self._handles)
+  if not ready_indexes then
+    return nil, poll_err
+  end
+
+  local ready = {}
+  for i, v in ipairs(ready_indexes) do
+    ready[i] = devs[v]
+  end
+  return ready
+end
+
+function Selector:events()
+  local ready = {}
+  local i = 1
+
+  return function()
+    while true do
+      while i <= #ready do
+        local dev = ready[i]
+        local event, err = dev:read()
+        if event then
+          return dev, event
+        end
+        if err then
+          error(err, 2)
+        end
+        i = i + 1
+      end
+
+      local next, err = self:poll()
+      if not next then
+        error(err, 2)
+      end
+      ready = next
+      i = 1
+    end
+  end
+end
+
+---@type evdev.selector
+local M = {}
+
+function M.new(devs)
+  validate("devices", devs, "table", true)
+  devs = devs or {}
+  local handles = {}
+
+  for i, dev in ipairs(devs) do
+    validate_device("devices[" .. i .. "]", dev)
+    handles[i] = rawget(dev, "_core")
+  end
+
+  return setmetatable({ _devices = devs, _handles = handles }, Selector)
+end
+
+return setmetatable(M, {
+  __call = function(_, devs)
+    return M.new(devs)
+  end,
+})

tests/selector.test.lua

@@ -0,0 +1,230 @@
+local evdev = require "evdev"
+
+local Selector = evdev.selector.new
+local Device = evdev.device.open
+
+describe("evdev.selector", function()
+  describe("new()", function()
+    it("creates selectors and manages devices", function()
+      local first = assert(Device("/dev/null"))
+      local second = assert(Device("/dev/null"))
+      local sel = Selector({ first })
+
+      assert.Table(sel)
+
+      assert(first:close())
+      assert(second:close())
+    end)
+
+    it("errors on invalid device lists", function()
+      assert.Error(function()
+        Selector(false) ---@diagnostic disable-line
+      end, "devices: (table expected, got boolean)")
+
+      assert.Error(function()
+        Selector({ {} }) ---@diagnostic disable-line
+      end, "devices[1]: (evdev.Device expected)")
+    end)
+  end)
+
+  describe("add()", function()
+    it("errors on non-device values", function()
+      local sel = Selector()
+
+      assert.Error(function()
+        sel:add(false) ---@diagnostic disable-line
+      end, "device: (evdev.Device expected)")
+
+      assert.Error(function()
+        sel:add({}) ---@diagnostic disable-line
+      end, "device: (evdev.Device expected)")
+    end)
+
+    it("ignores devices that are already registered", function()
+      local dev = assert(Device("/dev/null"))
+      local sel = Selector()
+
+      sel:add(dev):add(dev)
+
+      local ready = assert(sel:poll())
+      assert.Same({ dev }, ready)
+
+      dev:close()
+    end)
+  end)
+
+  describe("remove()", function()
+    it("errors on non-device values", function()
+      local sel = Selector()
+
+      assert.Error(function()
+        sel:remove(false) ---@diagnostic disable-line
+      end, "device: (evdev.Device expected)")
+
+      assert.Error(function()
+        sel:remove({}) ---@diagnostic disable-line
+      end, "device: (evdev.Device expected)")
+    end)
+  end)
+
+  describe("clear()", function()
+    it("removes all registered devices", function()
+      local first = assert(Device("/dev/null"))
+      local second = assert(Device("/dev/null"))
+      local sel = Selector({ first, second })
+      sel:clear()
+      first:close()
+      second:close()
+    end)
+  end)
+
+  describe("poll()", function()
+    it("returns registered devices that are ready", function()
+      local first = assert(Device("/dev/null"))
+      local second = assert(Device("/dev/null"))
+      local sel = evdev.selector({ first, second })
+      local ready, err = sel:poll()
+
+      assert.Nil(err)
+      assert.Same({ first, second }, ready)
+
+      first:close()
+      second:close()
+    end)
+
+    it("returns an error when no devices are registered", function()
+      local ready, err = Selector():poll()
+      assert.Nil(ready)
+      assert.Equal("devices must not be empty", err)
+    end)
+
+    it("returns an error when a registered device is closed", function()
+      local dev = assert(Device("/dev/null"))
+      local sel = evdev.selector({ dev })
+
+      dev:close()
+
+      local ready, err = sel:poll()
+      assert.Nil(ready)
+      assert.Equal("devices[1]: device is closed", err)
+    end)
+  end)
+
+  describe("events()", function()
+    it("yields events from registered devices", function()
+      local first = assert(Device("/dev/null"))
+      local second = assert(Device("/dev/null"))
+      local sel = Selector({ first, second })
+      local polled = false
+      local second_sent = false
+
+      function sel:poll()
+        if not polled then
+          polled = true
+          return { second, first }
+        end
+        return { first }
+      end
+
+      function first:read()
+        if polled then
+          polled = false
+          return {
+            device = self,
+            type = evdev.ecodes.EV_KEY,
+            code = evdev.ecodes.KEY_F24,
+            value = 1,
+          }
+        end
+      end
+
+      function second:read()
+        if second_sent then
+          return nil
+        end
+        second_sent = true
+        return {
+          device = self,
+          type = evdev.ecodes.EV_KEY,
+          code = evdev.ecodes.KEY_F23,
+          value = 0,
+        }
+      end
+
+      local events = sel:events()
+      local dev1, event1 = events()
+      local dev2, event2 = events()
+
+      first:close()
+      second:close()
+
+      assert.Equal(second, dev1)
+      assert.Equal(evdev.ecodes.KEY_F23, event1.code)
+      assert.Equal(first, dev2)
+      assert.Equal(evdev.ecodes.KEY_F24, event2.code)
+    end)
+
+    it("skips ready devices that return no event", function()
+      local first = assert(Device("/dev/null"))
+      local second = assert(Device("/dev/null"))
+      local sel = Selector({ first, second })
+
+      function sel:poll()
+        return { first, second }
+      end
+
+      function first:read() end
+
+      function second:read()
+        return {
+          device = self,
+          type = evdev.ecodes.EV_KEY,
+          code = evdev.ecodes.KEY_F24,
+          value = 1,
+        }
+      end
+
+      local dev, event = sel:events()()
+
+      first:close()
+      second:close()
+
+      assert.Equal(second, dev)
+      assert.Equal(evdev.ecodes.KEY_F24, event.code)
+    end)
+
+    it("raises poll errors", function()
+      local dev = assert(Device("/dev/null"))
+      local sel = Selector({ dev })
+
+      function sel:poll()
+        return nil, "poll failed"
+      end
+
+      assert.Error(function()
+        sel:events()()
+      end, "poll failed")
+
+      dev:close()
+    end)
+
+    it("raises read errors", function()
+      local dev = assert(Device("/dev/null"))
+      local sel = Selector({ dev })
+
+      function sel:poll()
+        return { dev }
+      end
+
+      function dev:read()
+        return nil, "read failed"
+      end
+
+      assert.Error(function()
+        sel:events()()
+      end, "read failed")
+
+      dev:close()
+    end)
+  end)
+end)