io-console 0.8.2-java → 0.9.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b840d62f5d17d3a367f0a978c107b39ecb08c59ca9a81d9bc9faf88041fbb909
-  data.tar.gz: 8c4dc753789ff1a4c6e2b5b5d1c55e6d5c1d59e9fffe308fd824578c6ec30a0b
+  metadata.gz: e86817ae95f9a6fc3fa3301ea895706a3071f8e500c3c2dec9ef669dae510609
+  data.tar.gz: 433bb663068ef08dbc2a076c0d037d94872f2906652bd198ee950fff5c3a1bc7
 SHA512:
-  metadata.gz: a2311dbec33c917c4033c6f1cad2e45e56c0d1e34b88ef5897d1d0e8e14003a9f4db6d15e0ffd24cd1e2ac3661a482729821f03e2c0a768bb9a67cd8276a18f5
-  data.tar.gz: '0398f065e2c7de6be4c33291c3ea050622de33cb01364b0b7443a89c3aed0afd3ff6e13f615174ae1a6803fb9b3280c6288d7b615ee2a7e929224684105bf33c'
+  metadata.gz: ec7274caecc4e434b7a1e7afe30251d1b07f677c54d3865f3b341c008f96ca6a7d95faa7c87faacbbf65734ee7a0e23bbdfb469088349a03c1cacc5f82be3bee
+  data.tar.gz: a9b72f79b80a65809217ed7cdab1edeb01daa53ffe9647d42900960569f4db3e83bb869c80f8da8ee9b2c76d23a66b08cc5d879a373a9ac9d9f6bdd05c0c8a66

data/lib/ffi/io/console/bsd_console.rb

@@ -6,7 +6,7 @@ if RbConfig::CONFIG['host_os'].downcase =~ /darwin/ && FFI::Platform::ARCH !~ /#
   raise LoadError.new("native console on MacOS only supported on #{tested_platforms.join(', ')}")
 end
 
-module IO::LibC
+module IO::Console::LibC
   extend FFI::Library
   ffi_lib FFI::Library::LIBC
 
@@ -170,3 +170,5 @@ module IO::LibC
   attach_function :tcflush, [ :int, :int ], :int
   attach_function :ioctl, [ :int, :ulong, :varargs ], :int
 end
+
+require_relative 'native_console'

data/lib/ffi/io/console/common.rb

@@ -1,4 +1,9 @@
 # Methods common to all backend impls
+require 'io/wait'
+
+module IO::Console
+end
+
 class IO
   # TODO: Windows version uses "conin$" and "conout$" instead of /dev/tty
   def self.console(sym = nil, *args)
@@ -62,12 +67,26 @@ class IO
     str.chomp
   end
 
+  def input_pending?
+    !wait_readable(0).nil?
+  end
+
+  def hide_cursor
+    write "\e[?25l"
+    self
+  end
+
+  def show_cursor
+    write "\e[?25h"
+    self
+  end
+
   def cursor
     raw do
       syswrite "\e[6n"
 
       return nil if getbyte != 0x1b
-      return nil if getbyte != ?[.ord
+      return nil if getbyte != "[".ord
 
       num = 0
       result = []

data/lib/ffi/io/console/linux_console.rb

@@ -6,7 +6,7 @@ unless FFI::Platform::ARCH =~ /#{tested_platforms.join('|')}/
   warn "native console only tested on #{tested_platforms.join(', ')}"
 end
 
-module IO::LibC
+module IO::Console::LibC
   extend FFI::Library
   ffi_lib FFI::Library::LIBC
 
@@ -202,3 +202,5 @@ module IO::LibC
   attach_function :tcflush, [ :int, :int ], :int
   attach_function :ioctl, [ :int, :ulong, :varargs ], :int
 end
+
+require_relative 'native_console'

data/lib/ffi/io/console/native_console.rb

@@ -1,15 +1,5 @@
-# Load appropriate native bits for BSD or Linux
-case RbConfig::CONFIG['host_os'].downcase
-when /darwin|openbsd|freebsd|netbsd/
-  require_relative 'bsd_console'
-when /linux/
-  require_relative 'linux_console'
-else
-  raise LoadError.new("no native io/console support")
-end
-
 # Common logic that uses native calls for console
-class IO
+module IO::Console
   def ttymode
     termios = LibC::Termios.new
     if LibC.tcgetattr(self.fileno, termios) != 0
@@ -18,21 +8,26 @@ class IO
 
     if block_given?
       yield tmp = termios.dup
-      if LibC.tcsetattr(self.fileno, LibC::TCSANOW, tmp) != 0
-        raise SystemCallError.new(respond_to?(:path) ? path : "tcsetattr(TCSANOW)", FFI.errno)
-      end
+      ttymode_set(tmp)
     end
     termios
   end
   private :ttymode
 
+  def ttymode_set(termios)
+    if LibC.tcsetattr(self.fileno, LibC::TCSANOW, termios) != 0
+      raise SystemCallError.new(respond_to?(:path) ? path : "tcsetattr(TCSANOW)", FFI.errno)
+    end
+  end
+  private :ttymode_set
+
   def ttymode_yield(block, **opts, &setup)
     begin
       orig_termios = ttymode { |t| setup.call(t, **opts) }
       block.call(self)
     ensure
-      if orig_termios && LibC.tcsetattr(self.fileno, LibC::TCSANOW, orig_termios) != 0
-        raise SystemCallError.new(respond_to?(:path) ? path : "tcsetattr(TCSANOW)", FFI.errno)
+      if orig_termios
+        ttymode_set(orig_termios)
       end
     end
   end
@@ -93,6 +88,46 @@ class IO
     ttymode_yield(block) { |t| t[:c_lflag] &= ~(TTY_ECHO) }
   end
 
+  class Mode
+    attr_reader :termios
+
+    def initialize(t)
+      @termios = t
+    end
+
+    def initialize_copy(m)
+      @termios = m.termios.dup
+    end
+
+    def echo=(echo)
+      if echo
+        @termios[:c_lflag] |= TTY_ECHO
+      else
+        @termios[:c_lflag] &= ~TTY_ECHO
+      end
+    end
+
+    def raw!(min: 1, time: nil, intr: nil)
+      TTY_RAW[@termios, min:, time:, intr:]
+      self
+    end
+
+    def raw(min: 1, time: nil, intr: nil)
+      new_mode = dup
+      TTY_RAW[new_mode.termios, min:, time:, intr:]
+      new_mode
+    end
+  end
+
+  def console_mode
+    Mode.new(ttymode)
+  end
+
+  def console_mode=(mode)
+    ttymode_set(mode.termios)
+    mode
+  end
+
   def winsize
     ws = LibC::Winsize.new
     if LibC.ioctl(self.fileno, LibC::TIOCGWINSZ, :pointer, ws.pointer) != 0
@@ -138,3 +173,7 @@ class IO
     raise SystemCallError.new("tcflush(TCIOFLUSH)", FFI.errno) unless LibC.tcflush(self.fileno, LibC::TCIOFLUSH) == 0
   end
 end
+
+class IO
+  include Console
+end

data/lib/ffi/io/console/stty_console.rb

@@ -1,6 +1,10 @@
 # attempt to call stty; if failure, raise error
-`stty 2> /dev/null`
-if $?.exitstatus != 0
+module IO::Console
+  STTY = %w[/usr/bin/stty /bin/stty].find {|path| File.executable?(path)}
+end
+
+unless IO::Console::STTY &&
+       system(IO::Console::STTY, out: File::NULL, err: %i[child out])
   raise "stty command returned nonzero exit status"
 end
 
@@ -8,46 +12,45 @@ warn "io/console on JRuby shells out to stty for most operations" if $VERBOSE
 
 # Non-Windows assumes stty command is available
 class IO
-  if RbConfig::CONFIG['host_os'].downcase =~ /linux/ && File.exists?("/proc/#{Process.pid}/fd")
-    protected def _io_console_stty(*args)
-      _io_console_stty_error { `stty #{args.join(' ')} < /proc/#{Process.pid}/fd/#{fileno}` }
-    end
-  else
-    protected def _io_console_stty(*args)
-      _io_console_stty_error { `stty #{args.join(' ')}` }
-    end
-  end
-
-  protected def _io_console_stty_error
+  private def _io_console_stty(*args)
     # pre-check to catch non-tty filenos we can't stty against anyway
     raise Errno::ENOTTY, inspect if !tty?
 
-    result = yield
-
-    case result
-    when /Inappropriate ioctl for device/
-      raise Errno.ENOTTY, inspect
+    IO.pipe do |re, we|
+      input = dup # workaround for JRuby
+      IO.popen([Console::STTY, *args, in: input, err: we], &:read)
+    ensure
+      input&.close
+      unless $?.success?
+        we.close
+        error = re.read
+        case error
+        when /Inappropriate ioctl for device/
+          raise Errno::ENOTTY, inspect
+        end
+        raise "stty command failed: #{error.chomp}"
+      end
     end
-
-    result
   end
 
   def raw(*, min: 1, time: nil, intr: nil)
-    saved = _io_console_stty('-g raw')
+    saved = _io_console_stty('-g')
+    _io_console_stty('raw')
     yield self
   ensure
-    _io_console_stty(saved)
+    _io_console_stty(saved) if saved
   end
 
   def raw!(*)
-    stty('raw')
+    _io_console_stty('raw')
   end
 
   def cooked(*)
-    saved = _io_console_stty('-g', '-raw')
+    saved = _io_console_stty('-g')
+    _io_console_stty('-raw')
     yield self
   ensure
-    _io_console_stty(saved)
+    _io_console_stty(saved) if saved
   end
 
   def cooked!(*)
@@ -63,10 +66,11 @@ class IO
   end
 
   def noecho
-    saved = _io_console_stty('-g', '-echo')
+    saved = _io_console_stty('-g')
+    _io_console_stty('-echo')
     yield self
   ensure
-    _io_console_stty(saved)
+    _io_console_stty(saved) if saved
   end
 
   # Not all systems return same format of stty -a output
@@ -74,7 +78,7 @@ class IO
   UBUNTU = 'rows (?<rows>\d+); columns (?<columns>\d+)'
 
   def winsize
-    match = _io_console_stty('-a').match(/#{IEEE_STD_1003_2}|#{UBUNTU}/)
+    match = _io_console_stty('-a').match(/#{IEEE_STD_1003_2}|#{UBUNTU}/o)
     [match[:rows].to_i, match[:columns].to_i]
   end
 

data/lib/ffi/io/console/version.rb

@@ -1,3 +1,5 @@
-class IO::ConsoleMode
-  VERSION = "0.8.2"
+class IO
+  module Console
+    VERSION = "0.9.1"
+  end
 end

data/lib/ffi/io/console/windows_console.rb

@@ -0,0 +1,293 @@
+require 'ffi'
+
+module IO::Console::Windows
+  STD_INPUT_HANDLE = -10
+  STD_OUTPUT_HANDLE = -11
+  WAIT_OBJECT_0 = 0
+  WAIT_TIMEOUT = 258
+  ENABLE_WRAP_AT_EOL_OUTPUT = 2
+  ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
+
+  module Native
+    extend FFI::Library
+    ffi_convention :stdcall
+    ffi_lib 'kernel32'
+    attach_function :GetStdHandle, [:int32], :pointer
+    attach_function :GetConsoleMode, [:pointer, :pointer], :int
+    attach_function :SetConsoleMode, [:pointer, :uint32], :int
+    attach_function :WaitForSingleObject, [:pointer, :uint32], :uint32
+    attach_function :ReadConsoleInputW,
+                    [:pointer, :pointer, :uint32, :pointer], :int
+    attach_function :GetFileType, [:pointer], :uint32
+    attach_function :GetFileInformationByHandleEx,
+                    [:pointer, :int, :pointer, :uint32], :int
+    attach_function :GetConsoleScreenBufferInfo, [:pointer, :pointer], :int
+    attach_function :SetConsoleCursorPosition, [:pointer, :uint32], :int
+    attach_function :FillConsoleOutputCharacterW,
+                    [:pointer, :uint16, :uint32, :uint32, :pointer], :int
+    attach_function :FillConsoleOutputAttribute,
+                    [:pointer, :uint16, :uint32, :uint32, :pointer], :int
+    attach_function :GetConsoleCursorInfo, [:pointer, :pointer], :int
+    attach_function :SetConsoleCursorInfo, [:pointer, :pointer], :int
+  end
+
+  module CRT
+    extend FFI::Library
+    ffi_convention :cdecl
+    ffi_lib 'msvcrt'
+    attach_function :_kbhit, [], :int
+  end
+
+  GetStdHandle = Native.method(:GetStdHandle)
+  GetConsoleMode = Native.method(:GetConsoleMode)
+  SetConsoleMode = Native.method(:SetConsoleMode)
+  WaitForSingleObject = Native.method(:WaitForSingleObject)
+  ReadConsoleInputW = Native.method(:ReadConsoleInputW)
+  GetFileType = Native.method(:GetFileType)
+  GetFileInformationByHandleEx = Native.method(:GetFileInformationByHandleEx)
+  GetConsoleScreenBufferInfo = Native.method(:GetConsoleScreenBufferInfo)
+  SetConsoleCursorPosition = Native.method(:SetConsoleCursorPosition)
+  FillConsoleOutputCharacter = Native.method(:FillConsoleOutputCharacterW)
+  FillConsoleOutputAttribute = Native.method(:FillConsoleOutputAttribute)
+  GetConsoleCursorInfo = Native.method(:GetConsoleCursorInfo)
+  SetConsoleCursorInfo = Native.method(:SetConsoleCursorInfo)
+  Kbhit = CRT.method(:_kbhit)
+
+  INPUT_HANDLE = GetStdHandle.call(STD_INPUT_HANDLE)
+  OUTPUT_HANDLE = GetStdHandle.call(STD_OUTPUT_HANDLE)
+
+  module_function
+
+  def handle(io)
+    io.equal?(STDIN) ? INPUT_HANDLE : OUTPUT_HANDLE
+  end
+
+  def console_mode(io)
+    buffer = "\0" * 4
+    raise SystemCallError, 'GetConsoleMode' if GetConsoleMode.call(handle(io), buffer) == 0
+    buffer.unpack1('L')
+  end
+
+  def set_console_mode(io, mode)
+    raise SystemCallError, 'SetConsoleMode' if SetConsoleMode.call(handle(io), mode) == 0
+  end
+
+  def screen_buffer_info(io)
+    buffer = "\0" * 22
+    raise SystemCallError, 'GetConsoleScreenBufferInfo' if GetConsoleScreenBufferInfo.call(handle(io), buffer) == 0
+    buffer.unpack('s9')
+  end
+
+  def coordinate(x, y)
+    (y & 0xffff) << 16 | (x & 0xffff)
+  end
+end
+
+module IO::Console::Windows::TTY
+  def tty?(*types)
+    return super() if types.empty?
+
+    default = msys = cygwin = false
+    types.each do |type|
+      case type
+      when nil
+        default = true
+      when :any
+        default = msys = cygwin = true
+      when :msys
+        msys = true
+      when :cygwin
+        cygwin = true
+      when Symbol
+        raise ArgumentError, "unknown tty type: #{type.inspect}"
+      else
+        raise TypeError, "expected Symbol, got #{type.class}"
+      end
+    end
+
+    return true if default && super()
+    (msys || cygwin) && msys_tty?(msys, cygwin)
+  end
+  alias isatty tty?
+
+  private def msys_tty?(msys, cygwin)
+    windows = IO::Console::Windows
+    handle = windows.handle(self)
+    return false unless windows::GetFileType.call(handle) == 3
+    buffer = "\0" * 1024
+    return false if windows::GetFileInformationByHandleEx.call(handle, 2, buffer, 1022) == 0
+    length = buffer.unpack1('L')
+    name = buffer[4, length].encode(Encoding::UTF_8, Encoding::UTF_16LE, invalid: :replace)
+    return false unless (msys && name.start_with?('\\msys-')) || (cygwin && name.start_with?('\\cygwin-'))
+    name.include?('-pty')
+  end
+end
+
+IO.prepend(IO::Console::Windows::TTY)
+
+class IO::ConsoleMode
+  def initialize(mode)
+    @mode = mode
+  end
+
+  def virtual_terminal_processing?
+    @mode & IO::Console::Windows::ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0
+  end
+
+  def virtual_terminal_processing=(enabled)
+    set_flag(IO::Console::Windows::ENABLE_VIRTUAL_TERMINAL_PROCESSING, enabled)
+  end
+
+  def wrap_at_eol_output?
+    @mode & IO::Console::Windows::ENABLE_WRAP_AT_EOL_OUTPUT != 0
+  end
+
+  def wrap_at_eol_output=(enabled)
+    set_flag(IO::Console::Windows::ENABLE_WRAP_AT_EOL_OUTPUT, enabled)
+  end
+
+  private def set_flag(flag, enabled)
+    enabled ? @mode |= flag : @mode &= ~flag
+    self
+  end
+
+  private def to_i
+    @mode
+  end
+end
+
+class IO
+  def console_mode
+    IO::ConsoleMode.new(IO::Console::Windows.console_mode(self))
+  end
+
+  def console_mode=(mode)
+    IO::Console::Windows.set_console_mode(self, mode.__send__(:to_i))
+    mode
+  end
+
+  def input_pending?
+    windows = IO::Console::Windows
+    return windows::Kbhit.call != 0 if windows::GetConsoleMode.call(windows.handle(self), "\0" * 4) != 0
+    respond_to?(:wait_readable) && !!wait_readable(0)
+  end
+
+  def console_input_events(max_events = 1, timeout: nil)
+    raise ArgumentError, 'max_events must be positive' unless max_events > 0
+    raise ArgumentError, 'time interval must not be negative' if timeout && timeout < 0
+
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout if timeout
+    loop do
+      wait = deadline && deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      return [] if wait && wait <= 0
+      milliseconds = wait ? [[(wait * 1000).ceil, 100].min, 0].max : 100
+      windows = IO::Console::Windows
+      result = windows::WaitForSingleObject.call(windows.handle(self), milliseconds)
+      break if result == windows::WAIT_OBJECT_0
+      return [] if result != windows::WAIT_TIMEOUT
+      return [] if deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+    end
+
+    records = "\0" * 20 * max_events
+    count = "\0" * 4
+    windows = IO::Console::Windows
+    if windows::ReadConsoleInputW.call(windows.handle(self), records, max_events, count) == 0
+      raise SystemCallError, 'ReadConsoleInputW'
+    end
+    count.unpack1('L').times.map do |index|
+      record = records[index * 20, 20]
+      event_type = record.unpack1('S')
+      case event_type
+      when 1
+        key_down, repeat_count, virtual_key_code, virtual_scan_code,
+          unicode_char, control_key_state = record[4, 16].unpack('LS4L')
+        {
+          type: :key, key_down: key_down != 0, repeat_count: repeat_count,
+          virtual_key_code: virtual_key_code, virtual_scan_code: virtual_scan_code,
+          unicode_char: unicode_char, control_key_state: control_key_state,
+        }
+      when 2
+        x, y, button_state, control_key_state, event_flags = record[4, 16].unpack('s2L3')
+        {type: :mouse, position: [y, x], button_state: button_state,
+         control_key_state: control_key_state, event_flags: event_flags}
+      when 4
+        x, y = record[4, 4].unpack('s2')
+        {type: :window_buffer_size, size: [y, x]}
+      when 8
+        {type: :menu, command_id: record[4, 4].unpack1('L')}
+      when 16
+        {type: :focus, set_focus: record[4, 4].unpack1('L') != 0}
+      else
+        {type: event_type}
+      end
+    end
+  end
+
+  def winsize
+    width, _, _, _, _, _, top, _, bottom = IO::Console::Windows.screen_buffer_info(self)
+    [bottom - top + 1, width]
+  end
+
+  def cursor
+    _, _, x, y, _, _, top, = IO::Console::Windows.screen_buffer_info(self)
+    [y - top, x]
+  end
+
+  def goto(row, column)
+    windows = IO::Console::Windows
+    _, _, _, _, _, _, top, = windows.screen_buffer_info(self)
+    position = windows.coordinate(column, row + top)
+    raise SystemCallError, 'SetConsoleCursorPosition' if windows::SetConsoleCursorPosition.call(windows.handle(self), position) == 0
+    self
+  end
+
+  def goto_column(column)
+    row, = cursor
+    goto(row, column)
+  end
+
+  def erase_line(mode)
+    raise ArgumentError, 'invalid line erase mode' unless (0..2).cover?(mode)
+    windows = IO::Console::Windows
+    width, _, x, y, attributes, = windows.screen_buffer_info(self)
+    start = mode == 0 ? x : 0
+    length = mode == 0 ? width - x : mode == 1 ? x + 1 : width
+    position = windows.coordinate(start, y)
+    written = "\0" * 4
+    windows::FillConsoleOutputCharacter.call(windows.handle(self), 0x20, length, position, written)
+    windows::FillConsoleOutputAttribute.call(windows.handle(self), attributes, length, position, written)
+    self
+  end
+
+  def clear_screen
+    windows = IO::Console::Windows
+    width, _, _, _, attributes, _, top, _, bottom = windows.screen_buffer_info(self)
+    length = width * (bottom - top + 1)
+    position = windows.coordinate(0, top)
+    written = "\0" * 4
+    windows::FillConsoleOutputCharacter.call(windows.handle(self), 0x20, length, position, written)
+    windows::FillConsoleOutputAttribute.call(windows.handle(self), attributes, length, position, written)
+    windows::SetConsoleCursorPosition.call(windows.handle(self), position)
+    self
+  end
+
+  def hide_cursor
+    set_cursor_visibility(false)
+  end
+
+  def show_cursor
+    set_cursor_visibility(true)
+  end
+
+  private def set_cursor_visibility(visible)
+    info = "\0" * 8
+    windows = IO::Console::Windows
+    handle = windows.handle(self)
+    raise SystemCallError, 'GetConsoleCursorInfo' if windows::GetConsoleCursorInfo.call(handle, info) == 0
+    size, = info.unpack('L2')
+    info = [size, visible ? 1 : 0].pack('L2')
+    raise SystemCallError, 'SetConsoleCursorInfo' if windows::SetConsoleCursorInfo.call(handle, info) == 0
+    self
+  end
+
+end

data/lib/ffi/io/console/windows_constants.rb

@@ -0,0 +1,26 @@
+module IO::Console::Windows
+  VK_TAB = 0x09
+  VK_RETURN = 0x0d
+  VK_SHIFT = 0x10
+  VK_CONTROL = 0x11
+  VK_MENU = 0x12
+  VK_END = 0x23
+  VK_HOME = 0x24
+  VK_LEFT = 0x25
+  VK_UP = 0x26
+  VK_RIGHT = 0x27
+  VK_DOWN = 0x28
+  VK_DELETE = 0x2e
+  VK_DIVIDE = 0x6f
+  VK_LMENU = 0xa4
+
+  RIGHT_ALT_PRESSED = 0x0001
+  LEFT_ALT_PRESSED = 0x0002
+  RIGHT_CTRL_PRESSED = 0x0004
+  LEFT_CTRL_PRESSED = 0x0008
+  SHIFT_PRESSED = 0x0010
+  NUMLOCK_ON = 0x0020
+  SCROLLLOCK_ON = 0x0040
+  CAPSLOCK_ON = 0x0080
+  ENHANCED_KEY = 0x0100
+end

data/lib/ffi/io/console.rb

@@ -24,51 +24,40 @@ require 'rbconfig'
 require_relative 'console/version'
 require_relative 'console/common'
 
-case RbConfig::CONFIG['host_os']
-when /darwin|openbsd|freebsd|netbsd|linux/i
-  # If Linux or BSD, try to load the native version
-
-  begin
-
-    # Attempt to load the native Linux and BSD console logic
-    require_relative 'console/native_console'
-
-  rescue Exception => ex
-
-    warn "failed to load native console support: #{ex}" if $VERBOSE
-
-  else
-
-    # Native ready.
-    ready = true
-
+class IO
+  module Console
+    class Mode
+      VERSION = Console::VERSION
+      deprecate_constant :VERSION
+    end
   end
 
-when /mswin|win32|ming/i
-  # If Windows, stty is not possible, always use the stub version
-
-  ready = false
-
+  ConsoleMode = Console::Mode
+  deprecate_constant :ConsoleMode
 end
 
-if ready.nil?
-  # Native is not ready, try to use stty
-
-  begin
-
-    require_relative 'console/stty_console'
-    ready = true
-
-  rescue Exception => ex2
-
-    warn "failed to load stty console support: #{ex2}" if $VERBOSE
-    ready = false
-
-  end
+libs = []
+# If Linux or BSD, try to load the native version
+case RbConfig::CONFIG['host_os'].downcase
+when /darwin|openbsd|freebsd|netbsd/
+  libs << 'bsd' << 'stty'
+when /linux/
+  libs << 'linux' << 'stty'
+when /mswin|win32|ming/i
+  require_relative 'console/windows_constants'
+  require_relative 'console/windows_console'
+  return
+else
+  libs << 'stty'
 end
 
-unless ready
-  # If still not ready, just use stubbed version
-
-  require_relative 'console/stub_console'
+return if libs.any? do |lib|
+  require_relative "console/#{lib}_console"
+rescue Exception => ex
+  warn "failed to load #{lib} console support: #{ex}" if $VERBOSE
+else
+  true
 end
+
+# If still not ready, just use stubbed version
+require_relative "console/stub_console"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: io-console
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.1
 platform: java
 authors:
 - Nobu Nakada
 bindir: bin
 cert_chain: []
-date: 2025-12-14 00:00:00.000000000 Z
+date: 2026-08-08 00:00:00.000000000 Z
 dependencies: []
 description: add console capabilities to IO instances.
 email: nobu@ruby-lang.org
@@ -27,6 +27,8 @@ files:
 - lib/ffi/io/console/stty_console.rb
 - lib/ffi/io/console/stub_console.rb
 - lib/ffi/io/console/version.rb
+- lib/ffi/io/console/windows_console.rb
+- lib/ffi/io/console/windows_constants.rb
 - lib/io/console/size.rb
 homepage: https://github.com/ruby/io-console
 licenses: