teek-ui 0.1.0

data/test/test_menu_realize.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+class TestMenuRealize < Minitest::Test
+  include TeekTestHelper
+
+  def test_menu_bar_attaches_to_the_root_window
+    assert_tk_app("a top-level menu_bar should attach via -menu to the root window") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.menu_bar(:mb) { |mb| mb.menu(label: 'File') }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal session[:mb].path, session.app.tcl_eval('. cget -menu')
+
+      session.app.destroy
+    end
+  end
+
+  def test_menu_bar_attaches_to_a_ui_window_not_just_the_root
+    assert_tk_app("a menu_bar declared inside ui.window should attach to that window, not the root") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.window(:settings) { |w| w.menu_bar(:mb) { |mb| mb.menu(label: 'File') } }
+      end
+      session.run_async
+      session.app.update
+
+      settings_path = session[:settings].path
+      assert_equal session[:mb].path, session.app.tcl_eval("#{settings_path} cget -menu")
+      refute_equal session[:mb].path, session.app.tcl_eval('. cget -menu'),
+        "the root window should not also pick up the settings window's menu bar"
+
+      session.app.destroy
+    end
+  end
+
+  def test_nested_menu_realizes_as_a_cascade_under_its_parents_path
+    assert_tk_app("a nested .menu should realize as a real menu widget, added as a cascade entry") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.menu_bar(:mb) { |mb| mb.menu(:file, label: 'File') }
+      end
+      session.run_async
+      session.app.update
+
+      mb_path = session[:mb].path
+      file_path = session[:file].path
+      assert session.app.winfo.exists?(file_path)
+      assert file_path.start_with?("#{mb_path}."),
+        "a submenu's path (#{file_path}) should be nested under its parent menu's path (#{mb_path}) - Tk requires it"
+
+      assert_equal 'cascade', session.app.tcl_eval("#{mb_path} type 0")
+      assert_equal 'File', session.app.command(mb_path, :entrycget, 0, '-label')
+      assert_equal file_path, session.app.command(mb_path, :entrycget, 0, '-menu')
+
+      session.app.destroy
+    end
+  end
+
+  def test_item_fires_its_block_on_invoke
+    assert_tk_app("a menu item's block should fire like any other command entry") do
+      require 'teek/ui'
+
+      fired = false
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.menu_bar { |mb| mb.menu(:file, label: 'File') { |f| f.item(label: 'Open') { fired = true } } }
+      end
+      session.run_async
+      session.app.update
+
+      session.app.tcl_eval("#{session[:file].path} invoke 0")
+
+      assert fired, "the item's block did not fire"
+
+      session.app.destroy
+    end
+  end
+
+  def test_named_item_is_addressable_via_ui_name_and_supports_enable_disable_configure
+    assert_tk_app("a named item should be addressable via ui[:name] and support .enable/.disable/.configure") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.menu_bar do |mb|
+          mb.menu(:file, label: 'File') do |f|
+            f.item(label: 'New') { }
+            f.item(:quick_load, label: 'Quick Load') { }
+          end
+        end
+      end
+      session.run_async
+      session.app.update
+
+      file_path = session[:file].path
+      item = session[:quick_load]
+
+      assert_equal 'normal', session.app.command(file_path, :entrycget, 1, '-state')
+
+      item.disable
+      assert_equal 'disabled', session.app.command(file_path, :entrycget, 1, '-state')
+
+      item.enable
+      assert_equal 'normal', session.app.command(file_path, :entrycget, 1, '-state')
+
+      item.configure(label: 'Load Recent Save')
+      assert_equal 'Load Recent Save', session.app.command(file_path, :entrycget, 1, '-label')
+
+      session.app.destroy
+    end
+  end
+
+  def test_named_item_stays_correctly_addressed_after_an_earlier_sibling_is_removed
+    assert_tk_app("addressing a named item should stay correct even after an earlier sibling entry is removed") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.menu_bar do |mb|
+          mb.menu(:file, label: 'File') do |f|
+            f.item(label: 'New') { }
+            f.item(:quick_load, label: 'Quick Load') { }
+          end
+        end
+      end
+      session.run_async
+      session.app.update
+
+      file_path = session[:file].path
+      # Removing "New" shifts Quick Load's live index from 1 down to 0 -
+      # Tk itself renumbers around the delete; addressing by name should
+      # still land on the right entry with no stale cached index.
+      session.app.command(file_path, :delete, 0)
+
+      session[:quick_load].disable
+
+      assert_equal 'disabled', session.app.command(file_path, :entrycget, 0, '-state')
+
+      session.app.destroy
+    end
+  end
+
+  def test_named_item_virtual_path_is_marked_and_rejected_by_a_raw_tk_call
+    assert_tk_app("a named item's .path should be marked past the real Tk boundary, and rejected if used raw") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.menu_bar { |mb| mb.menu(:file, label: 'File') { |f| f.item(:quick_load, label: 'Quick Load') { } } }
+      end
+      session.run_async
+      session.app.update
+
+      file_path = session[:file].path
+      virtual_path = session[:quick_load].path
+      assert_equal "#{file_path}!quick_load", virtual_path
+
+      error = assert_raises(Teek::TclError) { session.app.tcl_eval("#{virtual_path} entrycget 0 -label") }
+      assert_match(/invalid command name/i, error.message)
+
+      session.app.destroy
+    end
+  end
+
+  def test_separator_realizes_as_a_real_separator_entry
+    assert_tk_app("ui.separator should realize as a real Tk separator entry") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ui.menu_bar { |mb| mb.menu(:file, label: 'File') { |f| f.item(label: 'Open') { }; f.separator } }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal 'separator', session.app.tcl_eval("#{session[:file].path} type 1")
+
+      session.app.destroy
+    end
+  end
+
+  def test_checkbox_entry_stays_in_sync_with_its_bound_var
+    assert_tk_app("a menu checkbox entry bound to a var should toggle that var on invoke") do
+      require 'teek/ui'
+
+      wrap = nil
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        wrap = ui.var(false)
+        ui.menu_bar { |mb| mb.menu(:edit, label: 'Edit') { |e| e.checkbox(label: 'Word Wrap', bind: wrap) } }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal false, wrap.value
+
+      session.app.tcl_eval("#{session[:edit].path} invoke 0")
+
+      assert_equal true, wrap.value, "invoking the checkbutton entry should flip the bound var"
+
+      session.app.destroy
+    end
+  end
+
+  def test_radio_entries_share_one_var_and_set_its_own_value_on_invoke
+    assert_tk_app("menu radio entries bound to the same var should set it to their own value on invoke") do
+      require 'teek/ui'
+
+      size = nil
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        size = ui.var('small')
+        ui.menu_bar do |mb|
+          mb.menu(:edit, label: 'Edit') do |e|
+            e.radio(label: 'Small', bind: size, value: 'small')
+            e.radio(label: 'Large', bind: size, value: 'large')
+          end
+        end
+      end
+      session.run_async
+      session.app.update
+
+      session.app.tcl_eval("#{session[:edit].path} invoke 1")
+
+      assert_equal 'large', size.value
+
+      session.app.destroy
+    end
+  end
+
+  def test_rebuilding_a_menu_does_not_leak_entry_callbacks
+    assert_tk_app("rebuilding a context menu's contents on every right-click should not accumulate entry callbacks") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') { |ui| ui.panel(:host) }
+      session.run_async
+      session.app.update
+      baseline = session.app.interp.callback_ids.length
+
+      ctx = nil
+      5.times do
+        session.app.destroy(ctx.path) if ctx
+        session.add(:host) { |a| ctx = a.context_menu { |m| m.item(label: 'Delete') { }; m.item(label: 'Rename') { } } }
+      end
+      session.app.destroy(ctx.path)
+
+      assert_equal baseline, session.app.interp.callback_ids.length,
+        "rebuilding the context menu repeatedly should not accumulate callbacks"
+
+      session.app.destroy
+    end
+  end
+
+  def test_context_menu_pops_up_at_the_right_clicked_widgets_root_coordinates
+    assert_tk_app("a widget wired via on_right_click(context_menu) should tk_popup the right menu at the click's screen coordinates") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') do |ui|
+        ctx = ui.context_menu(:ctx) { |m| m.item(label: 'Delete') { } }
+        ui.canvas(:board).on_right_click(ctx)
+      end
+      session.run_async
+      session.app.update
+
+      session.app.tcl_eval(<<~TCL)
+        proc tk_popup {args} {
+          set ::last_popup_call $args
+        }
+      TCL
+
+      session.app.tcl_eval("event generate #{session[:board].path} <Button-3> -rootx 123 -rooty 456")
+
+      captured = session.app.split_list(session.app.tcl_eval('set ::last_popup_call'))
+      assert_equal [session[:ctx].path, '123', '456'], captured
+
+      session.app.destroy
+    end
+  end
+
+  def test_context_menu_declared_standalone_does_not_auto_attach_anywhere
+    assert_tk_app("a context_menu should exist as a real widget but never auto-attach via -menu") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Menu Realize Test') { |ui| ui.context_menu(:ctx) { |m| m.item(label: 'Delete') { } } }
+      session.run_async
+      session.app.update
+
+      assert session.app.winfo.exists?(session[:ctx].path)
+      assert_equal '', session.app.tcl_eval('. cget -menu')
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_modal_handle.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# Handle#modal/#grab_release are thin delegates to Teek::Window (see base
+# teek's own test_modal.rb) - no grab/focus/destroy-safety-net logic is
+# reimplemented here. These confirm the DSL layer actually wires through
+# to the real thing end to end, using the same grab current/status style
+# base teek's own tests use.
+#
+# A ui.window is withdrawn (not viewable) until shown - Tk's own `grab
+# set` requires a viewable window, so every test below calls .show first,
+# the same way a real caller would before making a window modal.
+class TestModalHandle < Minitest::Test
+  include TeekTestHelper
+
+  def test_modal_grabs_and_focuses_the_window
+    assert_tk_app("a window handle's modal should grab input and force focus onto it") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Modal Handle Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      session[:settings].show
+      session[:settings].modal
+
+      path = session[:settings].path
+      assert_equal path, session.app.tcl_eval("grab current #{path}")
+      assert_equal path, session.app.tcl_eval('focus')
+
+      session[:settings].grab_release
+      session.app.destroy
+    end
+  end
+
+  def test_grab_release_releases_the_grab
+    assert_tk_app("grab_release should clear the grab set by modal") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Modal Handle Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      session[:settings].show
+      session[:settings].modal
+      session[:settings].grab_release
+
+      path = session[:settings].path
+      assert_equal '', session.app.tcl_eval("grab current #{path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_modal_releases_the_grab_if_the_setup_block_raises
+    assert_tk_app("modal should release the grab immediately if its setup block raises, not leave it stuck") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Modal Handle Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+      session[:settings].show
+
+      path = session[:settings].path
+      error = assert_raises(RuntimeError) { session[:settings].modal { raise 'boom' } }
+      assert_equal 'boom', error.message
+
+      assert_equal '', session.app.tcl_eval("grab current #{path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_modal_grab_persists_after_a_successful_setup_block
+    assert_tk_app("modal's grab should still be held after a successful setup block - released explicitly, not automatically") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Modal Handle Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+      session[:settings].show
+
+      ran = false
+      session[:settings].modal { ran = true }
+
+      assert ran, "the setup block should run"
+      path = session[:settings].path
+      assert_equal path, session.app.tcl_eval("grab current #{path}")
+
+      session[:settings].grab_release
+      session.app.destroy
+    end
+  end
+
+  def test_modal_releases_the_grab_if_the_window_is_destroyed_while_grabbed
+    assert_tk_app("modal should release the grab if its window is destroyed without an explicit grab_release") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Modal Handle Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+      session[:settings].show
+
+      path = session[:settings].path
+      session[:settings].modal
+      assert_equal path, session.app.tcl_eval("grab current #{path}")
+
+      session.app.destroy(path)
+
+      assert_equal '', session.app.tcl_eval('grab current')
+
+      session.app.destroy
+    end
+  end
+
+  def test_modal_raises_on_a_non_window_handle
+    assert_tk_app("modal on a non-window handle should raise a clear error") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Modal Handle Test') { |ui| ui.button(:go, text: 'Go') }
+      session.run_async
+      session.app.update
+
+      error = assert_raises(ArgumentError) { session[:go].modal }
+      assert_match(/window/i, error.message)
+
+      session.app.destroy
+    end
+  end
+
+  def test_grab_release_raises_on_a_non_window_handle
+    assert_tk_app("grab_release on a non-window handle should raise a clear error") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Modal Handle Test') { |ui| ui.button(:go, text: 'Go') }
+      session.run_async
+      session.app.update
+
+      error = assert_raises(ArgumentError) { session[:go].grab_release }
+      assert_match(/window/i, error.message)
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_modal_stack.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'teek/ui/modal_stack'
+
+# Pure stack-bookkeeping and callback-lifecycle tests, no Tk involved -
+# ModalStack wraps Screens for the actual reveal/conceal, which is already
+# covered (headlessly and against real Tk) by test_screens.rb/
+# test_screens_realtk.rb. These focus on what's actually new here: when
+# on_enter/on_exit/on_focus_change fire.
+class TestModalStack < Minitest::Test
+  FakeWindow = Struct.new(:shows, :hides) do
+    def initialize(shows = [], hides = [])
+      super
+    end
+
+    def type
+      :window
+    end
+
+    def show
+      shows << true
+    end
+
+    def hide
+      hides << true
+    end
+  end
+
+  FakeLazyWindow = Struct.new(:shows, :hides, :realized_flag, :realize_calls) do
+    def initialize(shows = [], hides = [], realized_flag = false)
+      super(shows, hides, realized_flag, [])
+    end
+
+    def type
+      :window
+    end
+
+    def show
+      shows << true
+    end
+
+    def hide
+      hides << true
+    end
+
+    def realized?
+      realized_flag
+    end
+
+    def realize!(document)
+      realize_calls << document
+      self.realized_flag = true
+    end
+  end
+
+  def test_starts_empty
+    stack = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { })
+
+    refute stack.active?
+    assert_nil stack.current
+    assert_equal 0, stack.size
+  end
+
+  def test_push_on_an_empty_stack_fires_on_enter_and_on_focus_change_and_shows_the_window
+    enters = []
+    focus_changes = []
+    settings = FakeWindow.new
+    stack = Teek::UI::ModalStack.new(
+      on_enter: ->(name) { enters << name },
+      on_exit: -> { },
+      on_focus_change: ->(name) { focus_changes << name },
+    )
+
+    stack.push(:settings, settings)
+
+    assert stack.active?
+    assert_equal :settings, stack.current
+    assert_equal 1, stack.size
+    assert_equal [:settings], enters
+    assert_equal [:settings], focus_changes
+    assert_equal [true], settings.shows
+  end
+
+  def test_pushing_a_second_modal_does_not_fire_on_enter_again_but_hides_the_first_and_shows_the_second
+    enters = []
+    focus_changes = []
+    settings = FakeWindow.new
+    replay = FakeWindow.new
+    stack = Teek::UI::ModalStack.new(
+      on_enter: ->(name) { enters << name },
+      on_exit: -> { },
+      on_focus_change: ->(name) { focus_changes << name },
+    )
+    stack.push(:settings, settings)
+
+    stack.push(:replay, replay)
+
+    assert_equal :replay, stack.current
+    assert_equal 2, stack.size
+    assert_equal [:settings], enters, "on_enter should only fire on the empty -> non-empty transition"
+    assert_equal [:settings, :replay], focus_changes
+    assert_equal [true], settings.hides, "the previous top should be withdrawn, not dismissed"
+    assert_equal [true], replay.shows
+  end
+
+  def test_pop_with_a_modal_remaining_reveals_it_and_fires_on_focus_change_not_on_exit
+    exits = 0
+    focus_changes = []
+    settings = FakeWindow.new
+    replay = FakeWindow.new
+    stack = Teek::UI::ModalStack.new(
+      on_enter: ->(_) { },
+      on_exit: -> { exits += 1 },
+      on_focus_change: ->(name) { focus_changes << name },
+    )
+    stack.push(:settings, settings)
+    stack.push(:replay, replay)
+    focus_changes.clear
+
+    stack.pop
+
+    assert_equal :settings, stack.current
+    assert_equal 1, stack.size
+    assert_equal [true], replay.hides
+    assert_equal [true, true], settings.shows, "settings should be re-shown"
+    assert_equal [:settings], focus_changes
+    assert_equal 0, exits
+  end
+
+  def test_popping_the_last_modal_fires_on_exit_not_on_focus_change
+    exits = 0
+    focus_changes = []
+    settings = FakeWindow.new
+    stack = Teek::UI::ModalStack.new(
+      on_enter: ->(_) { },
+      on_exit: -> { exits += 1 },
+      on_focus_change: ->(name) { focus_changes << name },
+    )
+    stack.push(:settings, settings)
+    focus_changes.clear
+
+    stack.pop
+
+    refute stack.active?
+    assert_nil stack.current
+    assert_equal 0, stack.size
+    assert_equal [true], settings.hides
+    assert_equal 1, exits
+    assert_equal [], focus_changes
+  end
+
+  def test_pop_on_an_empty_stack_is_a_safe_no_op
+    exits = 0
+    stack = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { exits += 1 })
+
+    stack.pop
+
+    refute stack.active?
+    assert_equal 0, exits
+  end
+
+  def test_on_focus_change_is_optional
+    settings = FakeWindow.new
+    stack = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { })
+
+    stack.push(:settings, settings)
+    stack.pop
+
+    assert_equal [true], settings.shows
+    assert_equal [true], settings.hides
+  end
+
+  def test_document_is_forwarded_to_the_internal_screens_for_lazy_realize
+    settings = FakeLazyWindow.new
+    stack = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { }, document: :the_document)
+
+    stack.push(:settings, settings)
+
+    assert_equal [:the_document], settings.realize_calls
+  end
+
+  def test_pop_returns_the_popped_window
+    settings = FakeWindow.new
+    stack = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { })
+    stack.push(:settings, settings)
+
+    assert_same settings, stack.pop
+  end
+
+  def test_pop_on_an_empty_stack_returns_nil
+    stack = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { })
+
+    assert_nil stack.pop
+  end
+
+  def test_a_push_push_pop_pop_sequence_fires_on_enter_once_on_focus_change_thrice_on_exit_once
+    enters = []
+    exits = 0
+    focus_changes = []
+    settings = FakeWindow.new
+    replay = FakeWindow.new
+    stack = Teek::UI::ModalStack.new(
+      on_enter: ->(name) { enters << name },
+      on_exit: -> { exits += 1 },
+      on_focus_change: ->(name) { focus_changes << name },
+    )
+
+    stack.push(:settings, settings)
+    stack.push(:replay, replay)
+    stack.pop
+    stack.pop
+
+    assert_equal [:settings], enters
+    assert_equal [:settings, :replay, :settings], focus_changes
+    assert_equal 1, exits
+    refute stack.active?
+  end
+end