teek 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0f6bffdcb09e1d16bac89ae6d8a5595b72e33b0ae1e1d8b3a69bbad54e1cadc
-  data.tar.gz: 3d7ef3fe7168abd1f618577e01d02dfd9a43a91f2fe2a1fd27bff05c9cb73377
+  metadata.gz: 3ff08eb5884f74dc6461c5ff1163a025b44b798e2e480bd4f2855210dd0f0fdf
+  data.tar.gz: 8e012ccf6a6fffe427630c033b288f784ed455552b064870b0bce054d11e62ee
 SHA512:
-  metadata.gz: 6604babdbafe5641544ea288c017722a5c08660445945e715dac47335849165bb3245b2b024c5067fd8013f14cc9aba43965fea5703dc9ff91f71e8e438ab518
-  data.tar.gz: 8e146399dbc27889ed3284e1de07bfffcc6e83637afb6bc69ab22120410e18e23fcf35f5b0d5e6670dc0ca5062d0ecc6f505fac26cea0c610f628103d065b07e
+  metadata.gz: 878e28a9a7493abdccdce1a4b28e372ade4648b12392cdb0815581b4590ab69b601eceb1da686e01719c6930fe1e88c333d4751e80f3af7875ce84a2a391957c
+  data.tar.gz: 0cd4b0ae71353720e185455e3966b954b9b2e2237417ce0efc596ad9915234f6b79923d318a54a1f42ddf9a839e8e58857462017192f750cd1d4ef31ce92710a

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in teek.gemspec
 gemspec
+
+gem 'rubyzip', '>= 2.4', '< 4'

data/README.md

@@ -104,25 +104,54 @@ If a callback raises a Ruby exception, it becomes a Tcl error. The exception mes
 
 ## Menus
 
-Build a menu bar with standard `menu` widgets:
+Build a menu bar with `App#menu`:
 
 ```ruby
 app = Teek::App.new(title: 'My App')
 
-app.command(:menu, '.menubar')
-app.command('.', :configure, menu: '.menubar')
+menubar = app.menu('.menubar')
+app.command('.', :configure, menu: menubar)
 
-app.command(:menu, '.menubar.file', tearoff: 0)
-app.command('.menubar', :add, :cascade, label: 'File', menu: '.menubar.file')
-app.command('.menubar.file', :add, :command,
-           label: 'Quit', command: proc { app.command(:destroy, '.') })
+file_menu = app.menu('.menubar.file')
+menubar.command(:add, :cascade, label: 'File', menu: file_menu)
+file_menu.command(:add, :command, label: 'Quit', command: proc { app.command(:destroy, '.') })
 
 app.show
 app.mainloop
 ```
 
+`app.menu(path)` creates the underlying Tk menu the first time it's called for a given path (tearoff disabled) and just returns a handle to it on later calls, so it's safe to call again whenever you're about to rebuild a menu's entries (e.g. on every right-click). Every entry-mutating call — `add`, `insert`, `entryconfigure`, `delete` — tracks any `command:` callback and releases it when the entry is replaced, deleted, or the menu itself is destroyed. That's true whether you call it through the `Widget` handle (`menubar.command(:add, ...)`) or as a raw `app.command(path, :add, ...)`; both go through the same tracking, so there's no less-safe way to build a menu.
+
 > **macOS note:** On macOS, Tk always displays a menu bar. If you don't configure one, Tk shows a default menu with items like "Run Widget Demo" that are meant for the Tcl interpreter shell. Attach a custom menu bar (even an empty one) to suppress it. See the [TkDocs menu tutorial](https://tkdocs.com/tutorial/menus.html) for details.
 
+## Dialogs
+
+`App` has safe wrappers for the standard Tk dialogs — `choose_open_file`, `choose_save_file`, `message_box`, `choose_color`, and `popup_menu` — built without any string interpolation, so titles, paths, and messages containing spaces or braces are passed through correctly:
+
+```ruby
+path = app.choose_open_file(
+  title: 'Open Image',
+  filetypes: [['Images', ['.png', '.jpg']], ['All Files', '*']]
+)
+
+app.message_box(message: 'Really delete this?', type: :yesno, icon: :warning) # => :yes / :no
+```
+
+File/color pickers return `nil` when cancelled (an array of paths if `multiple: true`); `message_box` returns the pressed button as a symbol. See `sample/dialogs/dialogs_demo.rb` for a runnable demo of all five.
+
+## Window info
+
+`app.winfo` groups typed wrappers for Tk's `winfo` command family — one method per query, coerced to the right Ruby type:
+
+```ruby
+app.winfo.width(btn)      # => 90 (Integer)
+app.winfo.exists?(btn)    # => true / false
+app.winfo.class_name(btn) # => "TButton"
+app.winfo.pointerx        # => current mouse x, screen pixels
+```
+
+Every method accepts a path string or anything with a matching `to_s` (a `Widget`, for instance). `Widget` also has `#width`, `#height`, and `#exist?` convenience methods that delegate here for its own path.
+
 ## List operations
 
 Convert between Ruby arrays and Tcl list strings:
@@ -242,3 +271,29 @@ task.stop    # Stop completely
 The work block runs in a background Ractor and cannot access Tk directly. Use `t.yield()` to send results to `on_progress`, which runs on the main thread where Tk is available. Callbacks (`on_progress`, `on_done`) can be chained in any order.
 
 See [`sample/threading_demo.rb`](sample/threading_demo.rb) for a complete file hasher example.
+
+## File Drop Target
+
+Register any widget as a file drop target to receive OS-native drag-and-drop:
+
+```ruby
+app = Teek::App.new(title: "Drop Demo")
+app.show
+
+app.register_drop_target('.')
+
+app.bind('.', '<<DropFile>>', :data) do |data|
+  paths = app.split_list(data)
+  puts "Dropped: #{paths.inspect}"
+end
+
+app.mainloop
+```
+
+Dropped files arrive as a Tcl list in the `:data` substitution. Use `split_list` to get a Ruby array of paths. Works on macOS (Cocoa), Windows (OLE IDropTarget), and Linux (X11 XDND).
+
+See [`sample/drop_demo.rb`](sample/drop_demo.rb) for a complete example.
+
+## Known Issues
+
+- **File drop on Linux/Wayland** — `register_drop_target` does not yet work under Wayland. The current implementation uses the X11 XDND protocol, which is not compatible with Wayland's native drag-and-drop. Workaround: select an Xorg/X11 session at the login screen (e.g., "GNOME on Xorg"). Native Wayland support via `wl_data_device` is planned.

data/Rakefile

@@ -2,9 +2,84 @@ require "bundler/gem_tasks"
 require 'rake/testtask'
 require 'rake/clean'
 
-# Sub-project Rakefiles (define sdl2:compile, mgba:compile)
+# Sub-project Rakefiles (define sdl2:compile)
 import 'teek-sdl2/Rakefile'
-import 'teek-mgba/Rakefile'
+
+desc 'Run clang-tidy on C code'
+task :lint do
+  # Find clang-tidy binary
+  clang_tidy = nil
+
+  # Try system PATH first (Linux, or if user has llvm in PATH)
+  if system('which clang-tidy > /dev/null 2>&1')
+    clang_tidy = 'clang-tidy'
+  # On macOS, check Homebrew LLVM (keg-only, not in PATH by default)
+  elsif system('which brew > /dev/null 2>&1')
+    llvm_prefix = `brew --prefix llvm 2>/dev/null`.strip
+    clang_tidy = "#{llvm_prefix}/bin/clang-tidy" if !llvm_prefix.empty? && File.exist?("#{llvm_prefix}/bin/clang-tidy")
+  end
+
+  unless clang_tidy
+    abort("clang-tidy not installed.\n  " \
+          "macOS: brew install llvm\n  " \
+          "Ubuntu/Debian: apt-get install clang-tidy\n  " \
+          'Fedora/RHEL: dnf install clang-tools-extra')
+  end
+
+  puts 'Running clang-tidy on C code...'
+
+  # Find all .c files in ext/cataract/ and ext/cataract_color/
+  c_files = Dir.glob('ext/teek/**/*.c') + Dir.glob('teek-sdl2/ext/**/*.c')
+
+  # Run clang-tidy on each file
+  # Note: clang-tidy uses the .clang-tidy config file automatically
+  # We pass Ruby include path so it can find ruby.h
+  ruby_include = RbConfig::CONFIG['rubyhdrdir']
+  ruby_arch_include = RbConfig::CONFIG['rubyarchhdrdir']
+
+  # Without an explicit -I, clang-tidy falls back to whatever tcl.h/tk.h it
+  # finds on the default system search path - on macOS that's Apple's own
+  # ancient bundled Tcl/Tk 8.5 (symlinked into the Command Line Tools SDK),
+  # not the Homebrew tcl-tk this project actually builds against. That
+  # header unconditionally needs X11/Xlib.h, which isn't in the SDK -
+  # hence "file not found" even though the real build works fine.
+  # pkg-config points at the same tcl-tk include dir extconf.rb uses,
+  # which also bundles its own vendored X11 headers alongside tk.h, so no
+  # separate X11 lookup is needed.
+  tcltk_cflags = `pkg-config --cflags tcl tk 2>/dev/null`.strip.split
+  if tcltk_cflags.empty?
+    warn "Warning: pkg-config couldn't find tcl/tk - clang-tidy may pick up " \
+         "the wrong (or no) tcl.h/tk.h. Install tcl-tk via Homebrew/apt, or " \
+         "ensure pkg-config can see it."
+  end
+
+  # Same story for teek-sdl2: no explicit -I means clang-tidy won't find
+  # SDL2/SDL.h (and friends) at all, since SDL2 has no system-bundled
+  # fallback to silently misresolve to - it just fails outright.
+  sdl2_cflags = `pkg-config --cflags sdl2 SDL2_ttf SDL2_image SDL2_mixer 2>/dev/null`.strip.split
+  if sdl2_cflags.empty?
+    warn "Warning: pkg-config couldn't find SDL2 - clang-tidy will fail on " \
+         "teek-sdl2/ext/**/*.c. Install SDL2 (+ ttf/image/mixer) via " \
+         "Homebrew/apt, or ensure pkg-config can see it."
+  end
+
+  success = c_files.all? do |file|
+    puts "  Checking #{file}..."
+    system(clang_tidy, '--quiet', file, '--',
+           "-I#{ruby_include}",
+           "-I#{ruby_arch_include}",
+           '-Iext/teek',
+           '-Iteek-sdl2/ext',
+           *tcltk_cflags,
+           *sdl2_cflags)
+  end
+
+  if success
+    puts '✓ clang-tidy passed'
+  else
+    abort('clang-tidy found issues!')
+  end
+end
 
 # Documentation tasks - all doc gems are in docs_site/Gemfile
 namespace :docs do
@@ -112,7 +187,6 @@ task yard: 'docs:yard'
 CLEAN.include('ext/teek/config_list')
 CLOBBER.include('tmp', 'lib/*.bundle', 'lib/*.so', 'ext/**/*.o', 'ext/**/*.bundle', 'ext/**/*.bundle.dSYM')
 CLOBBER.include('teek-sdl2/lib/*.bundle', 'teek-sdl2/lib/*.so', 'teek-sdl2/ext/**/*.o', 'teek-sdl2/ext/**/*.bundle')
-CLOBBER.include('teek-mgba/lib/*.bundle', 'teek-mgba/lib/*.so', 'teek-mgba/ext/**/*.o', 'teek-mgba/ext/**/*.bundle')
 
 # Clean coverage artifacts before test runs to prevent accumulation
 CLEAN.include('coverage/.resultset.json', 'coverage/results')
@@ -219,84 +293,45 @@ namespace :sdl2 do
   task test: 'sdl2:compile'
 end
 
-namespace :mgba do
-  Rake::TestTask.new(:test) do |t|
-    t.libs << 'teek-mgba/test' << 'teek-mgba/lib' << 'teek-sdl2/lib'
-    t.test_files = FileList['teek-mgba/test/**/test_*.rb'] - FileList['teek-mgba/test/test_helper.rb']
-    t.ruby_opts << '-r test_helper'
-    t.verbose = true
-  end
-  task test: ['mgba:compile', 'sdl2:compile']
-
-  desc "Download and build libmgba from source (for macOS / platforms without libmgba-dev)"
-  task :deps do
-    require 'fileutils'
-    require 'etc'
-
-    vendor_dir  = File.expand_path('teek-mgba/vendor')
-    mgba_src    = File.join(vendor_dir, 'mgba')
-    build_dir   = File.join(vendor_dir, 'build')
-    install_dir = File.join(vendor_dir, 'install')
-
-    unless File.directory?(mgba_src)
-      FileUtils.mkdir_p(vendor_dir)
-      sh "git clone --depth 1 --branch 0.10.3 https://github.com/mgba-emu/mgba.git #{mgba_src}"
-    end
-
-    FileUtils.mkdir_p(build_dir)
-    cmake_flags = %W[
-      -DBUILD_SHARED=OFF
-      -DBUILD_STATIC=ON
-      -DBUILD_QT=OFF
-      -DBUILD_SDL=OFF
-      -DBUILD_GL=OFF
-      -DBUILD_GLES2=OFF
-      -DBUILD_GLES3=OFF
-      -DBUILD_LIBRETRO=OFF
-      -DSKIP_FRONTEND=ON
-      -DUSE_SQLITE3=OFF
-      -DUSE_ELF=OFF
-      -DUSE_LZMA=OFF
-      -DUSE_EDITLINE=OFF
-      -DCMAKE_INSTALL_PREFIX=#{install_dir}
-      -DCMAKE_POLICY_VERSION_MINIMUM=3.5
-    ].join(' ')
-
-    sh "cmake -S #{mgba_src} -B #{build_dir} #{cmake_flags}"
-    sh "cmake --build #{build_dir} -j #{Etc.nprocessors}"
-    sh "cmake --install #{build_dir}"
-
-    puts "libmgba built and installed to #{install_dir}"
-  end
-end
-
 task :default => :compile
 
 namespace :release do
-  desc "Build gems, install to temp dir, run smoke test"
+  desc "Clean-slate smoke test: clobber, build gems, install fresh, verify"
   task :smoke do
     require 'tmpdir'
     require 'fileutils'
 
+    # Clean slate — nuke compiled extensions so nothing local leaks in
+    puts "Clobbering local build artifacts..."
+    Rake::Task['clobber'].invoke
+    Rake::Task['sdl2:clobber'].invoke
+
     Dir.mktmpdir('teek-smoke') do |tmpdir|
       gem_home = File.join(tmpdir, 'gems')
 
       # Build both gems
-      puts "Building gems..."
+      puts "\nBuilding gems..."
       sh "gem build teek.gemspec -o #{tmpdir}/teek.gem 2>&1"
       Dir.chdir('teek-sdl2') { sh "gem build teek-sdl2.gemspec -o #{tmpdir}/teek-sdl2.gem 2>&1" }
 
-      # Install into isolated GEM_HOME
-      puts "\nInstalling gems..."
+      # Install into isolated GEM_HOME (no system gems, no stale versions)
+      puts "\nInstalling gems into #{gem_home}..."
       sh "GEM_HOME=#{gem_home} gem install #{tmpdir}/teek.gem --no-document 2>&1"
       sh "GEM_HOME=#{gem_home} gem install #{tmpdir}/teek-sdl2.gem --no-document 2>&1"
 
       # Run smoke test using only the installed gems (no -I, no bundle)
-      puts "\nRunning SDL2 smoke test..."
+      puts "\nRunning smoke test..."
       smoke = <<~'RUBY'
         require "teek"
         require "teek/sdl2"
 
+        # Verify native extensions loaded from gem path, not local source
+        %w[tcltklib teek_sdl2].each do |ext|
+          path = $LOADED_FEATURES.find { |f| f.include?(ext) && f.end_with?(".bundle", ".so", ".dll") }
+          abort "#{ext}: native extension not found in $LOADED_FEATURES" unless path
+          abort "#{ext}: loaded from local source (#{path}), not installed gem" if path.include?("/ext/")
+        end
+
         app = Teek::App.new
         app.set_window_title("Release Smoke Test")
         app.set_window_geometry("320x240")
@@ -305,6 +340,7 @@ namespace :release do
 
         vp = Teek::SDL2::Viewport.new(app, width: 300, height: 200)
         vp.pack
+        app.update
 
         vp.render do |r|
           r.clear(30, 30, 30)
@@ -319,7 +355,7 @@ namespace :release do
 
         app.after(500) { vp.destroy; app.destroy }
         app.mainloop
-        puts "Release smoke test passed (teek #{Teek::VERSION}, teek-sdl2 #{Teek::SDL2::VERSION})"
+        puts "release:smoke OK — teek #{Teek::VERSION}, teek-sdl2 #{Teek::SDL2::VERSION}"
       RUBY
 
       smoke_file = File.join(tmpdir, 'smoke.rb')
@@ -474,32 +510,7 @@ namespace :docker do
       sh cmd
     end
 
-    desc "Run teek-mgba tests in Docker"
-    task mgba: :build do
-      tcl_version = tcl_version_from_env
-      ruby_version = ruby_version_from_env
-      image_name = docker_image_name(tcl_version, ruby_version)
-
-      require 'fileutils'
-      FileUtils.mkdir_p('coverage')
-
-      warn_if_containers_running(image_name)
-
-      puts "Running teek-mgba tests in Docker (Ruby #{ruby_version}, Tcl #{tcl_version})..."
-      cmd = "docker run --rm --init"
-      cmd += " -v #{Dir.pwd}/coverage:/app/coverage"
-      cmd += " -e TCL_VERSION=#{tcl_version}"
-      if ENV['COVERAGE'] == '1'
-        cmd += " -e COVERAGE=1"
-        cmd += " -e COVERAGE_NAME=#{ENV['COVERAGE_NAME'] || 'mgba'}"
-      end
-      cmd += " #{image_name}"
-      cmd += " xvfb-run -a bundle exec rake mgba:test"
-
-      sh cmd
-    end
-
-    desc "Run all tests (teek + teek-sdl2 + teek-mgba) with coverage and generate report"
+    desc "Run all tests (teek + teek-sdl2) with coverage and generate report"
     task all: 'docker:build' do
       tcl_version = tcl_version_from_env
       ruby_version = ruby_version_from_env
@@ -520,11 +531,6 @@ namespace :docker do
       Rake::Task['docker:build'].reenable
       Rake::Task['docker:test:sdl2'].invoke
 
-      ENV['COVERAGE_NAME'] = 'mgba'
-      Rake::Task['docker:test:mgba'].reenable
-      Rake::Task['docker:build'].reenable
-      Rake::Task['docker:test:mgba'].invoke
-
       # Collate inside Docker (paths match /app/lib/...)
       puts "Collating coverage results..."
       cmd = "docker run --rm --init"

data/ext/teek/extconf.rb

@@ -26,6 +26,21 @@ def find_tcltk
       if File.exist?("#{inc}/tcl-tk/tcl.h")
         inc = "#{inc}/tcl-tk"
       end
+
+      # Check for versioned subdirectories (Debian/Ubuntu layout:
+      # /usr/include/tcl9.0/tcl.h, /usr/include/tcl8.6/tcl.h)
+      unless File.exist?("#{inc}/tcl.h")
+        versioned = Dir.glob("#{inc}/tcl*/tcl.h").max
+        if versioned
+          tcl_ver_dir = File.dirname(versioned)
+          tk_ver_dir = tcl_ver_dir.sub(/tcl/, 'tk')
+          $INCFLAGS << " -I#{tcl_ver_dir}"
+          $INCFLAGS << " -I#{tk_ver_dir}" if File.directory?(tk_ver_dir)
+          $LDFLAGS << " -L#{lib}"
+          break
+        end
+      end
+
       if File.exist?("#{inc}/tcl.h") && File.exist?("#{inc}/tk.h")
         $INCFLAGS << " -I#{inc}"
         $LDFLAGS << " -L#{lib}"

data/ext/teek/tcltkbridge.c

@@ -584,6 +584,70 @@ interp_unregister_callback(VALUE self, VALUE id)
     return Qnil;
 }
 
+/* ---------------------------------------------------------
+ * Interp#callback_ids - Currently registered callback id strings
+ * (test/introspection use: asserting exactly which ids survive a
+ * release, not just how many)
+ * --------------------------------------------------------- */
+
+static VALUE
+interp_callback_ids(VALUE self)
+{
+    struct tcltk_interp *tip = get_interp(self);
+    return rb_funcall(tip->callbacks, rb_intern("keys"), 0);
+}
+
+/* ---------------------------------------------------------
+ * Raise Teek::TclError for a Tcl_Eval/Tcl_EvalObjv failure, attaching
+ * errorInfo/errorCode via Tcl_GetReturnOptions - the return options are
+ * tied to the specific result code just returned, not the mutable
+ * ::errorInfo/::errorCode globals, so this is safe even though it runs
+ * after control has already left Tcl_Eval/Tcl_EvalObjv.
+ * --------------------------------------------------------- */
+
+static VALUE
+tclobj_to_rb_str_or_nil(Tcl_Obj *obj)
+{
+    Tcl_Size len;
+    const char *str;
+
+    if (obj == NULL) return Qnil;
+    str = Tcl_GetStringFromObj(obj, &len);
+    return rb_utf8_str_new(str, len);
+}
+
+NORETURN(static void raise_tcl_error(Tcl_Interp *interp, int code));
+
+static void
+raise_tcl_error(Tcl_Interp *interp, int code)
+{
+    Tcl_Obj *options, *einfo_key, *ecode_key;
+    Tcl_Obj *einfo_val = NULL, *ecode_val = NULL;
+    VALUE msg, backtrace, error_code, exc;
+
+    options = Tcl_GetReturnOptions(interp, code);
+    Tcl_IncrRefCount(options);
+
+    einfo_key = Tcl_NewStringObj("-errorinfo", -1);
+    ecode_key = Tcl_NewStringObj("-errorcode", -1);
+    Tcl_IncrRefCount(einfo_key);
+    Tcl_IncrRefCount(ecode_key);
+
+    Tcl_DictObjGet(interp, options, einfo_key, &einfo_val);
+    Tcl_DictObjGet(interp, options, ecode_key, &ecode_val);
+
+    msg = rb_utf8_str_new_cstr(Tcl_GetStringResult(interp));
+    backtrace = tclobj_to_rb_str_or_nil(einfo_val);
+    error_code = tclobj_to_rb_str_or_nil(ecode_val);
+
+    Tcl_DecrRefCount(einfo_key);
+    Tcl_DecrRefCount(ecode_key);
+    Tcl_DecrRefCount(options);
+
+    exc = rb_funcall(eTclError, rb_intern("new"), 3, msg, backtrace, error_code);
+    rb_exc_raise(exc);
+}
+
 /* ---------------------------------------------------------
  * Thread-safe event queue: run Ruby proc on main Tcl thread
  *
@@ -606,7 +670,7 @@ execute_queued_eval(VALUE arg)
     int result = Tcl_Eval(tip->interp, script_cstr);
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
     return rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
 }
@@ -647,7 +711,7 @@ execute_queued_invoke(VALUE arg)
     }
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
     return rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
 }
@@ -818,7 +882,7 @@ interp_tcl_eval(VALUE self, VALUE script)
     result = Tcl_Eval(tip->interp, script_cstr);
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
 
     return rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
@@ -883,7 +947,7 @@ interp_tcl_invoke(int argc, VALUE *argv, VALUE self)
     }
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
 
     ret = rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
@@ -1504,6 +1568,7 @@ Init_tcltklib(void)
     rb_define_method(cInterp, "mainloop", interp_mainloop, 0);
     rb_define_method(cInterp, "register_callback", interp_register_callback, 1);
     rb_define_method(cInterp, "unregister_callback", interp_unregister_callback, 1);
+    rb_define_method(cInterp, "callback_ids", interp_callback_ids, 0);
     rb_define_method(cInterp, "create_slave", interp_create_slave, -1);
     rb_define_method(cInterp, "thread_timer_ms", interp_get_thread_timer_ms, 0);
     rb_define_method(cInterp, "thread_timer_ms=", interp_set_thread_timer_ms, 1);

data/ext/teek/tkdrop_x11.c

@@ -48,8 +48,8 @@ static int
 hex_decode(const char *s)
 {
     int hi, lo;
-    hi = s[0];
-    lo = s[1];
+    hi = (unsigned char)s[0];
+    lo = (unsigned char)s[1];
     if (hi >= '0' && hi <= '9') hi -= '0';
     else if (hi >= 'a' && hi <= 'f') hi = hi - 'a' + 10;
     else if (hi >= 'A' && hi <= 'F') hi = hi - 'A' + 10;

data/lib/teek/callback_registry.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Teek
+  # Tracks Ruby callback ids scoped to something narrower than a whole
+  # widget - keyed by (container, key) pairs - so they can be released
+  # again without waiting for a <Destroy> that may never come for the
+  # thing the callback is actually attached to (an event binding, a menu
+  # entry, ...). A single instance is shared across every feature that
+  # needs this; callers namespace their own container keys (by
+  # convention, [feature_tag, path] tuples) so two features tracking the
+  # same underlying path never collide.
+  #
+  # There is exactly one way to keep the registry in sync: {#reconcile}.
+  # Its block is handed the {key => id} hash tracked last time and must
+  # return the {key => id} hash that should be tracked now; whatever id
+  # drops out between the two gets released. What the block *does* with
+  # the hash it's handed is entirely up to the caller - reuse its values
+  # as a starting point for a cheap in-memory update (nothing external
+  # can silently change an event binding), or ignore it and recompute
+  # the truth from scratch by asking Tk (Tk silently renumbers menu
+  # entries, so nothing short of asking can be trusted there). The
+  # registry itself never knows or cares which one a caller chose.
+  #
+  # The one hard rule either way: the returned hash must be a DIFFERENT
+  # object from the one the block was handed - e.g. +before.merge(...)+,
+  # never +before.merge!(...)+ returned as-is. Released ids are computed
+  # as +before.values - after.values+; if the block mutates +before+ in
+  # place and returns that same object, +before+ and +after+ are
+  # identical by the time that subtraction runs, so any id that was
+  # dropped or replaced is silently never released - a leak, the exact
+  # thing this class exists to prevent.
+  #
+  # {#forget_all_for_path} is the only thing a <Destroy> handler needs to
+  # call: it releases every container ever registered under a path,
+  # regardless of which feature created it, via a reverse index built
+  # automatically as a side effect of {#reconcile}.
+  class CallbackRegistry
+    def initialize(app)
+      @app = app
+      @entries = Hash.new { |h, k| h[k] = {} }
+      @containers_by_path = Hash.new { |h, k| h[k] = Set.new }
+    end
+
+    # @yieldparam before [Hash] the {key => id} hash tracked for +container+
+    #   as of the last call (empty on the first call)
+    # @yieldreturn [Hash] the {key => id} hash that should be tracked now -
+    #   must be a different object from +before+ (see class docs above);
+    #   do not mutate +before+ in place and return it, or dropped/replaced
+    #   ids silently never get released
+    # @return [void]
+    def reconcile(container)
+      track(container)
+      before = @entries[container]
+      after = yield(before)
+      (before.values - after.values).each { |id| @app.unregister_callback(id) }
+      @entries[container] = after
+    end
+
+    # Release every callback tracked under any container registered for
+    # +path+, regardless of which feature created it, and forget them.
+    # @return [void]
+    def forget_all_for_path(path)
+      containers = @containers_by_path.delete(path)
+      return unless containers
+      containers.each do |container|
+        ids = @entries.delete(container)
+        ids&.each_value { |id| @app.unregister_callback(id) }
+      end
+    end
+
+    private
+
+    # Convention, not a type check: every container is [feature_tag, path].
+    def track(container)
+      @containers_by_path[container.last] << container
+    end
+  end
+end

data/lib/teek/canvas_bind_interceptor.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'command_interceptors'
+require_relative 'callback_registry'
+
+module Teek
+  # @api private
+  #
+  # Registered for the "canvas" {CommandInterceptors} entry below.
+  #
+  # Canvas items aren't windows (only the canvas itself is one), so a bound
+  # item's callback never fires <Destroy> on its own, and `canvas delete`
+  # is silent - the same leak shape menu entries have. Unlike menu or
+  # text/treeview tags, canvas has no "list every live binding" enumeration
+  # command (no analogue to menu's `index end` or text's `tag names`), so
+  # this can't do a full-scan reconcile. Instead it re-queries only the
+  # (tagOrId, sequence) keys it already knows about - via `canvas bind
+  # tagOrId sequence`, the 2-arg read form - after every bind/delete call,
+  # and lets whatever no longer resolves drop out.
+  #
+  # A binding on a numeric item id is released this way once that item is
+  # deleted (Tk's Tk_DeleteAllBindings clears its binding-table entries
+  # along with it). A binding on a tag is NOT released by deleting a
+  # tagged item - the tag itself isn't an item, so its binding-table entry
+  # persists independent of which (if any) items currently carry that tag.
+  module CanvasBindInterceptor
+    MUTATING_SUBCOMMANDS = %w[bind delete].freeze
+
+    def self.call(app, path, args, kwargs)
+      sub = args[0]&.to_s
+      return nil unless MUTATING_SUBCOMMANDS.include?(sub)
+
+      result = app.raw_command(path, *args, **kwargs)
+      app.callback_registry.reconcile([:canvas_bind, path]) { |before| requery(app, path, before, sub, args) }
+      result
+    end
+
+    def self.requery(app, path, before, sub, args)
+      keys = before.keys
+      keys += [[args[1].to_s, args[2].to_s]] if sub == 'bind' && args.length >= 4
+
+      keys.uniq.each_with_object({}) do |(tag_or_id, seq), after|
+        # Unlike a tag (a plain Tcl string, always a valid query target even
+        # if nothing currently carries it), a numeric item id is a hash key
+        # into the canvas's item table - querying one after its item is
+        # deleted raises "item \"N\" doesn't exist" rather than returning
+        # empty, so a deleted item's binding has to be dropped via rescue,
+        # not by checking the result.
+        current = begin
+          app.tcl_eval("#{path} bind #{tag_or_id} #{seq}")
+        rescue Teek::TclError
+          ''
+        end
+        # \z anchors this to a BARE `ruby_callback <id>` with nothing
+        # after. raw_command's generic positional-Proc handling
+        # technically allows a caller to pass %-substitutions to a
+        # canvas-bind-shaped app.command call (the same mechanism
+        # App#bind uses), but nothing in teek does that today. If a
+        # caller ever does, this regex silently stops matching and that
+        # id leaks on rebuild/delete - drop the \z anchor (match just
+        # the leading `ruby_callback <id>`) if that changes.
+        after[[tag_or_id, seq]] = Regexp.last_match(1) if current =~ /\Aruby_callback (\S+)\z/
+      end
+    end
+  end
+
+  CommandInterceptors.register('canvas', 'canvas_bind') { |*a| CanvasBindInterceptor.call(*a) }
+end