teek-ui 0.1.0

data/test/test_close_handling.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# Under Xvfb there's no real window manager reliably sending a genuine
+# WM_DELETE_WINDOW client message - these read back the script on_close
+# registered via `wm protocol` and eval it directly, the same "read back
+# and invoke" approach already used elsewhere in this suite (canvas item
+# bindings, treeview heading commands) and in the base teek gem's own
+# on_close tests.
+
+class TestCloseHandling < Minitest::Test
+  include TeekTestHelper
+
+  def test_on_close_fires_on_a_simulated_close
+    assert_tk_app("win.on_close should fire when WM_DELETE_WINDOW is simulated") do
+      require 'teek/ui'
+
+      closed = false
+      session = Teek::UI.app(title: 'Close Handling Test') do |ui|
+        ui.window(:settings).on_close { closed = true }
+      end
+      session.run_async
+      session.app.update
+
+      path = session[:settings].path
+      script = session.app.tcl_eval("wm protocol #{path} WM_DELETE_WINDOW")
+      session.app.tcl_eval(script)
+
+      assert closed, "on_close block did not fire"
+
+      session.app.destroy
+    end
+  end
+
+  def test_on_close_does_not_auto_destroy_the_window
+    assert_tk_app("on_close should not implicitly destroy the window - that's the block's own call") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Close Handling Test') do |ui|
+        ui.window(:settings).on_close { }
+      end
+      session.run_async
+      session.app.update
+
+      path = session[:settings].path
+      script = session.app.tcl_eval("wm protocol #{path} WM_DELETE_WINDOW")
+      session.app.tcl_eval(script)
+
+      assert session.app.winfo.exists?(path), "on_close must not destroy the window itself unless the block chooses to"
+
+      session.app.destroy
+    end
+  end
+
+  def test_on_close_block_can_choose_to_destroy_the_window
+    assert_tk_app("an on_close block that destroys the window should actually close it") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Close Handling Test') do |ui|
+        ui.window(:settings).on_close { session.app.destroy(session[:settings].path) }
+      end
+      session.run_async
+      session.app.update
+
+      path = session[:settings].path
+      script = session.app.tcl_eval("wm protocol #{path} WM_DELETE_WINDOW")
+      session.app.tcl_eval(script)
+
+      refute session.app.winfo.exists?(path)
+
+      session.app.destroy
+    end
+  end
+
+  def test_rebinding_on_close_replaces_rather_than_leaks
+    assert_tk_app("calling on_close again should replace the handler, not accumulate a callback") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Close Handling Test') do |ui|
+        ui.window(:settings).on_close { }
+      end
+      session.run_async
+      session.app.update
+      baseline = session.app.interp.callback_ids.length
+
+      fired_new = false
+      session[:settings].on_close { fired_new = true }
+
+      assert_equal baseline, session.app.interp.callback_ids.length,
+        "rebinding on_close should replace, not accumulate, the tracked callback"
+
+      path = session[:settings].path
+      script = session.app.tcl_eval("wm protocol #{path} WM_DELETE_WINDOW")
+      session.app.tcl_eval(script)
+
+      assert fired_new, "the replaced on_close handler should be the one that fires"
+
+      session.app.destroy
+    end
+  end
+
+  def test_on_close_raises_on_a_non_window_handle
+    assert_tk_app("on_close on a non-window handle should raise a clear error") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Close Handling Test') { |ui| ui.button(:go, text: 'Go') }
+      session.run_async
+      session.app.update
+
+      error = assert_raises(ArgumentError) { session[:go].on_close { } }
+      assert_match(/window/i, error.message)
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_component.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'teek/ui/session'
+
+# ui.component opens a fresh Scope around its block, so the SAME local
+# name declared in two different components never collides - a plain
+# threaded-builder method (def foo(ui) = ui.row { ... }) needs none of
+# this and keeps working unchanged; ui.component is only for the
+# opt-in case where scope isolation matters (reuse, avoiding name
+# collisions across files).
+class TestComponent < Minitest::Test
+  def build_session
+    Teek::UI::Session.new(title: 'Component Test')
+  end
+
+  def test_component_splices_its_subtree_under_the_current_parent
+    session = build_session
+
+    session.panel(:sidebar) { |p| p.component { |c| c.button(:save, text: 'Save') } }
+
+    sidebar_node = session.document.root.children.first
+    assert_equal :panel, sidebar_node.type
+    assert_equal [:button], sidebar_node.children.map(&:type),
+      "the component's own node should attach directly to :sidebar, with no extra wrapper container"
+  end
+
+  def test_the_same_local_name_in_two_different_components_does_not_collide
+    session = build_session
+
+    session.component { |c| c.button(:save, text: 'Save A') }
+    session.component { |c| c.button(:save, text: 'Save B') }
+
+    # neither #component call raised - that's the assertion. Confirm both
+    # nodes actually exist, independently, under the document root.
+    assert_equal 2, session.document.root.children.length
+    assert_equal ['Save A', 'Save B'], session.document.root.children.map { |n| n.opts[:text] }
+  end
+
+  def test_ui_bracket_inside_a_component_resolves_to_that_components_own_node
+    session = build_session
+    inner_lookup = nil
+
+    session.component do |c|
+      c.button(:save, text: 'Save')
+      inner_lookup = c[:save]
+    end
+
+    refute_nil inner_lookup
+    assert_equal :button, inner_lookup.type
+  end
+
+  def test_ui_bracket_inside_a_component_does_not_see_a_top_level_node_of_the_same_name
+    session = build_session
+    session.button(:save, text: 'Top-level Save')
+    inner_lookup = :not_set
+
+    session.component { |c| inner_lookup = c[:save] }
+
+    assert_nil inner_lookup, "a component's ui[:save] should not resolve to an unrelated top-level :save"
+  end
+
+  def test_ui_bracket_outside_any_component_does_not_see_a_components_node
+    session = build_session
+
+    session.component { |c| c.button(:save, text: 'Component Save') }
+
+    assert_nil session[:save], "top-level ui[:save] should not resolve into a component's own scope"
+  end
+
+  def test_ui_bracket_at_top_level_is_unaffected_by_components_existing
+    session = build_session
+    session.button(:go, text: 'Go')
+    session.component { |c| c.button(:save, text: 'Save') }
+
+    handle = session[:go]
+
+    refute_nil handle
+    assert_equal :button, handle.type
+  end
+
+  def test_two_components_can_use_the_same_label_without_colliding
+    session = build_session
+
+    session.component(:row) { |c| c.button(:save, text: 'First') }
+    session.component(:row) { |c| c.button(:save, text: 'Second') }
+
+    assert_equal 2, session.document.root.children.length
+    assert_equal ['First', 'Second'], session.document.root.children.map { |n| n.opts[:text] }
+  end
+
+  def test_threaded_builder_style_still_works_with_no_component_call_at_all
+    session = build_session
+    toolbar = ->(ui) { ui.row { |r| r.button(:save, text: 'Save') } }
+
+    session.panel(:p) { |p| toolbar.call(p) }
+
+    assert_equal :button, session[:save].type
+  end
+
+  def test_component_requires_no_tk_interpreter_to_exercise
+    session = build_session
+
+    session.component { |c| c.button(:save, text: 'Save') }
+
+    # reaching this line with no Teek::App/interpreter involved anywhere
+    # above IS the assertion - scoping is pure Ruby.
+    assert session.document.root.children.any?
+  end
+
+  def test_component_returns_a_facade_that_resolves_its_own_named_handle
+    session = build_session
+
+    facade = session.component { |c| c.button(:save, text: 'Save') }
+
+    handle = facade.handle(:save)
+    refute_nil handle
+    assert_equal :button, handle.type
+  end
+
+  def test_facade_bracket_is_an_alias_for_handle
+    session = build_session
+
+    facade = session.component { |c| c.button(:save, text: 'Save') }
+
+    assert_equal facade.handle(:save).type, facade[:save].type
+    refute_nil facade[:save]
+  end
+
+  def test_facade_returns_nil_for_a_name_the_component_never_declared
+    session = build_session
+
+    facade = session.component { |c| c.button(:save, text: 'Save') }
+
+    assert_nil facade[:not_declared]
+  end
+
+  def test_facade_still_resolves_its_own_names_when_mounted_under_different_parents
+    session = build_session
+
+    facade_a = nil
+    facade_b = nil
+    session.panel(:left) { |p| facade_a = p.component { |c| c.button(:save, text: 'Left Save') } }
+    session.panel(:right) { |p| facade_b = p.component { |c| c.button(:save, text: 'Right Save') } }
+
+    refute_nil facade_a[:save]
+    refute_nil facade_b[:save]
+    assert_equal :button, facade_a[:save].type
+    assert_equal :button, facade_b[:save].type
+  end
+end

data/test/test_component_realtk.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# Real-Tk half of ui.component's coverage - scoping itself (name
+# collisions, ui[:name] resolution) is pure Ruby, covered headlessly in
+# test_component.rb; this confirms the realized side: two components'
+# like-named children land at distinct, real Tk paths with no extra work
+# needed from Realizer - allocate_path already builds a path from each
+# node's OWN parent chain, and two components mounted under different
+# parents are never Tk siblings of each other.
+class TestComponentRealTk < Minitest::Test
+  include TeekTestHelper
+
+  def test_two_components_like_named_children_get_distinct_tk_paths
+    assert_tk_app("two components under different parents should realize distinct paths for their like-named children") do
+      require 'teek/ui'
+
+      save_a = nil
+      save_b = nil
+      session = Teek::UI.app(title: 'Component Test') do |ui|
+        ui.panel(:sidebar) { |p| p.component { |c| save_a = c.button(:save, text: 'Save A') } }
+        ui.panel(:main) { |p| p.component { |c| save_b = c.button(:save, text: 'Save B') } }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal "#{session[:sidebar].path}.save", save_a.path
+      assert_equal "#{session[:main].path}.save", save_b.path
+      refute_equal save_a.path, save_b.path
+
+      assert session.app.winfo.exists?(save_a.path)
+      assert session.app.winfo.exists?(save_b.path)
+      assert_equal 'Save A', session.app.command(save_a.path, :cget, '-text')
+      assert_equal 'Save B', session.app.command(save_b.path, :cget, '-text')
+
+      session.app.destroy
+    end
+  end
+
+  def test_a_components_facade_only_ever_resolves_that_components_own_node
+    assert_tk_app("a component's facade should resolve to its own :save, never a sibling component's like-named one") do
+      require 'teek/ui'
+
+      facade_a = nil
+      facade_b = nil
+      session = Teek::UI.app(title: 'Component Test') do |ui|
+        ui.panel(:sidebar) { |p| facade_a = p.component { |c| c.button(:save, text: 'Save A') } }
+        ui.panel(:main) { |p| facade_b = p.component { |c| c.button(:save, text: 'Save B') } }
+      end
+      session.run_async
+      session.app.update
+
+      handle_a = facade_a[:save]
+      handle_b = facade_b[:save]
+
+      refute_equal handle_a.path, handle_b.path
+      assert_equal 'Save A', session.app.command(handle_a.path, :cget, '-text')
+      assert_equal 'Save B', session.app.command(handle_b.path, :cget, '-text')
+
+      handle_a.configure(text: 'Changed A')
+      assert_equal 'Changed A', session.app.command(handle_a.path, :cget, '-text')
+      assert_equal 'Save B', session.app.command(handle_b.path, :cget, '-text'),
+        "mutating component A's facade handle should never affect component B's widget"
+
+      session.app.destroy
+    end
+  end
+
+  def test_mounting_the_same_component_three_times_under_one_parent_gets_three_distinct_paths
+    assert_tk_app("mounting the same component 3x directly under one parent (not each under its own sub-panel) should realize 3 distinct :save widgets, each addressable through its own mount's facade") do
+      require 'teek/ui'
+
+      row = ->(ui, label) { ui.component { |c| c.button(:save, text: label) } }
+
+      facades = []
+      session = Teek::UI.app(title: 'Component Test') do |ui|
+        ui.panel(:list) { |p| 3.times { |i| facades << row.call(p, "Row #{i + 1}") } }
+      end
+      session.run_async
+      session.app.update
+
+      paths = facades.map { |f| f[:save].path }
+      assert_equal 3, paths.uniq.length, "each mount's :save should realize its own distinct Tk path (got #{paths.inspect})"
+      assert_equal ['Row 1', 'Row 2', 'Row 3'], paths.map { |path| session.app.command(path, :cget, '-text') }
+
+      facades[1][:save].configure(text: 'Changed')
+      assert_equal 'Row 1', session.app.command(paths[0], :cget, '-text')
+      assert_equal 'Changed', session.app.command(paths[1], :cget, '-text'),
+        "configuring through the second mount's facade should mutate the second mount's own widget"
+      assert_equal 'Row 3', session.app.command(paths[2], :cget, '-text')
+
+      session.app.destroy
+    end
+  end
+
+  def test_an_event_bound_inside_a_repeated_mount_fires_for_that_mounts_own_widget_only
+    assert_tk_app("a click handler declared inside one mount of a 3x-repeated component should fire only for that mount's own widget, never a sibling mount's") do
+      require 'teek/ui'
+
+      fired = []
+      row = ->(ui, label) { ui.component { |c| c.button(:save, text: label).on_click { fired << label } } }
+
+      facades = []
+      session = Teek::UI.app(title: 'Component Test') do |ui|
+        ui.panel(:list) { |p| 3.times { |i| facades << row.call(p, "Row #{i + 1}") } }
+      end
+      session.run_async
+      session.app.update
+
+      session.app.tcl_eval("event generate #{facades[1][:save].path} <Button-1>")
+      session.app.update
+
+      assert_equal ['Row 2'], fired, "clicking the second mount's widget should fire only its own handler"
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_debug_info.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# Aggregate callback/leak diagnostics: Session#debug_info (programmatic)
+# and run/run_async's debug: true (prints the same summary to STDERR).
+# Both are thin wrappers over Teek::CallbackRegistry#counts_by_tag,
+# which already has its own dedicated, headless coverage in teek core's
+# own test/test_callback_registry.rb - these focus on teek-ui's own
+# wiring (realize-only guard, friendly key names, the debug: printout),
+# not re-proving the registry's own counting logic.
+class TestDebugInfo < Minitest::Test
+  include TeekTestHelper
+
+  def test_debug_info_raises_before_realize
+    assert_tk_app("session.debug_info should raise before realize, matching every other realize-only diagnostic") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Debug Info Test')
+
+      assert_raises(Teek::UI::NotRealizedError) { session.debug_info }
+    end
+  end
+
+  def test_debug_info_reports_an_event_binding
+    assert_tk_app("debug_info should count a wired on_click as an event binding") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Debug Info Test') { |ui| ui.button(:go, text: 'Go').on_click { } }
+      session.run_async
+      session.app.update
+
+      assert_equal 1, session.debug_info[:event_bindings]
+
+      session.app.destroy
+    end
+  end
+
+  def test_debug_info_reports_a_menu_entry
+    assert_tk_app("debug_info should count a menu item's own command callback as a menu entry") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Debug Info Test') do |ui|
+        ui.menu_bar { |mb| mb.menu(:file, label: 'File') { |f| f.item(label: 'Open') { } } }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal 1, session.debug_info[:menu_entries]
+
+      session.app.destroy
+    end
+  end
+
+  def test_debug_info_reports_a_canvas_item_bind
+    assert_tk_app("debug_info should count a canvas item's on_click as a canvas item bind") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Debug Info Test') { |ui| ui.canvas(:board, width: 100, height: 100) }
+      session.run_async
+      session.app.update
+      session[:board].oval(0, 0, 10, 10).on_click { }
+
+      assert_equal 1, session.debug_info[:canvas_item_binds]
+
+      session.app.destroy
+    end
+  end
+
+  def test_debug_info_reports_a_widget_option_callback
+    assert_tk_app("debug_info should count a bare -command option (e.g. from a Var bind:) as a widget-option callback") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Debug Info Test') do |ui|
+        wrap = ui.var(false)
+        ui.checkbox(:agree, bind: wrap)
+      end
+      session.run_async
+      session.app.update
+      # a plain -variable bind doesn't register a Ruby callback on its
+      # own - drive a real -command option through the escape hatch to
+      # exercise this category directly, matching what App#command's own
+      # -command handling (the :widget_option tag) actually tracks.
+      session.app.command(session[:agree].path, :configure, command: -> { })
+
+      assert_equal 1, session.debug_info[:widget_option_callbacks]
+
+      session.app.destroy
+    end
+  end
+
+  def test_debug_info_returns_to_baseline_after_destroying_the_widgets
+    assert_tk_app("creating N event bindings then destroying those widgets should return the count to baseline, not just count monotonically upward") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Debug Info Test') { |ui| ui.panel(:host) }
+      session.run_async
+      session.app.update
+      baseline = session.debug_info[:event_bindings] || 0
+
+      handles = []
+      session.add(:host) do |a|
+        3.times { |i| handles << a.button(text: "Item #{i}").on_click { } }
+      end
+      session.app.update
+
+      assert_equal baseline + 3, session.debug_info[:event_bindings]
+
+      handles.each { |h| h.destroy!(defer: false) }
+      session.app.update
+
+      assert_equal baseline, session.debug_info[:event_bindings] || 0,
+        "destroying the widgets should release their callbacks, bringing the count back to baseline"
+
+      session.app.destroy
+    end
+  end
+
+  def test_run_async_debug_true_prints_a_summary_to_stderr
+    assert_tk_app("run_async(debug: true) should print the same grouped summary to stderr right after realize") do
+      require 'teek/ui'
+
+      _out, err = capture_io do
+        session = Teek::UI.app(title: 'Debug Info Test') { |ui| ui.button(:go, text: 'Go').on_click { } }
+        session.run_async(debug: true)
+        session.app.destroy
+      end
+
+      assert_match(/event_bindings/, err)
+      assert_match(/1/, err)
+    end
+  end
+
+  def test_run_async_without_debug_prints_nothing
+    assert_tk_app("run_async with no debug: (default false) should print nothing") do
+      require 'teek/ui'
+
+      _out, err = capture_io do
+        session = Teek::UI.app(title: 'Debug Info Test') { |ui| ui.button(:go, text: 'Go').on_click { } }
+        session.run_async
+        session.app.destroy
+      end
+
+      assert_empty err
+    end
+  end
+
+  # #run's own "print before and after mainloop" isn't covered by a
+  # live, blocking-mainloop test here - there's no existing precedent in
+  # this suite for scheduling a self-destroy to unblock #run from inside
+  # a test, and #run/#run_async share the exact same
+  # realize -> show -> print_debug_info sequence up to the point #run
+  # additionally calls #mainloop, which run_async's own debug: tests
+  # above already cover. The second print (after mainloop returns) is
+  # the same print_debug_info call, unconditionally placed right after
+  # the #mainloop line - see Session#run's own source.
+end