teek-ui 0.1.0

data/test/test_managed_window.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# ui.window/ui.dialog are a DSL primitive for managed toplevels: title/
+# geometry/resizable/transient setup at realize, withdrawn by default,
+# shown/hidden via Handle#show/#hide - which position near their parent,
+# deiconify+raise, and (when declared modal: true) grab+focus/release,
+# reusing the modal primitive already built on the handle rather than
+# reimplementing any of it.
+class TestManagedWindow < Minitest::Test
+  include TeekTestHelper
+
+  def test_window_is_withdrawn_by_default_after_realize
+    assert_tk_app("a ui.window should start withdrawn, not visible, until shown") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      refute session.app.winfo.ismapped?(session[:settings].path),
+        "a freshly realized window should be withdrawn by default"
+
+      session.app.destroy
+    end
+  end
+
+  def test_title_and_geometry_are_applied_at_realize
+    assert_tk_app("title:/geometry: opts should be applied via wm at realize") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') do |ui|
+        ui.window(:settings, title: 'Settings', geometry: '300x200')
+      end
+      session.run_async
+      session.app.update
+
+      path = session[:settings].path
+      assert_equal 'Settings', session.app.tcl_eval("wm title #{path}")
+
+      # geometry requested while withdrawn doesn't reliably read back until
+      # the window is actually mapped and idle tasks run - same reason
+      # base teek's own test_set_window_geometry shows the window first.
+      session[:settings].show
+      session.app.update_idletasks
+      assert_includes session.app.tcl_eval("wm geometry #{path}"), '300x200'
+
+      session.app.destroy
+    end
+  end
+
+  def test_resizable_opt_accepts_a_single_boolean_for_both_axes
+    assert_tk_app("resizable: false should set both width and height non-resizable") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') do |ui|
+        ui.window(:settings, resizable: false)
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal '0 0', session.app.tcl_eval("wm resizable #{session[:settings].path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_resizable_opt_accepts_a_width_height_pair
+    assert_tk_app("resizable: [true, false] should set width/height independently") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') do |ui|
+        ui.window(:settings, resizable: [true, false])
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal '1 0', session.app.tcl_eval("wm resizable #{session[:settings].path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_window_defaults_to_leaving_resizable_untouched
+    assert_tk_app("without a resizable: opt, Tk's own default (resizable both ways) should apply") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      assert_equal '1 1', session.app.tcl_eval("wm resizable #{session[:settings].path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_window_is_transient_to_its_parent_by_default
+    assert_tk_app("a top-level ui.window should be transient to the root window by default") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      assert_equal '.', session.app.tcl_eval("wm transient #{session[:settings].path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_nested_window_is_transient_to_its_enclosing_window_not_the_root
+    assert_tk_app("a ui.window nested inside another ui.window should be transient to that window") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') do |ui|
+        ui.window(:outer) { |o| o.window(:inner) }
+      end
+      session.run_async
+      session.app.update
+
+      outer_path = session[:outer].path
+      inner_path = session[:inner].path
+      assert_equal outer_path, session.app.tcl_eval("wm transient #{inner_path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_transient_false_disables_it
+    assert_tk_app("transient: false should leave the window with no transient parent") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') do |ui|
+        ui.window(:settings, transient: false)
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal '', session.app.tcl_eval("wm transient #{session[:settings].path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_show_deiconifies_raises_and_positions_near_its_parent
+    assert_tk_app("show should map the window and position it just to the right of its parent") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      root_x, root_y, root_w, = session.app.interp.window_geometry('.')
+      session[:settings].show
+      session.app.update
+
+      assert session.app.winfo.ismapped?(session[:settings].path)
+      settings_x, settings_y, = session.app.interp.window_geometry(session[:settings].path)
+      assert_equal root_x + root_w + 12, settings_x
+      assert_equal root_y, settings_y
+
+      session.app.destroy
+    end
+  end
+
+  def test_hide_withdraws_the_window
+    assert_tk_app("hide should withdraw a previously shown window") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      session[:settings].show
+      session.app.update
+      assert session.app.winfo.ismapped?(session[:settings].path)
+
+      session[:settings].hide
+      session.app.update
+      refute session.app.winfo.ismapped?(session[:settings].path)
+
+      session.app.destroy
+    end
+  end
+
+  def test_show_grabs_and_focuses_when_declared_modal
+    assert_tk_app("show should grab input and force focus when the window was declared modal: true") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings, modal: true) }
+      session.run_async
+      session.app.update
+
+      session[:settings].show
+      session.app.update
+
+      path = session[:settings].path
+      assert_equal path, session.app.tcl_eval("grab current #{path}")
+      assert_equal path, session.app.tcl_eval('focus')
+
+      session.app.destroy
+    end
+  end
+
+  def test_show_does_not_grab_when_not_declared_modal
+    assert_tk_app("show should not grab input for an ordinary (non-modal) window") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings) }
+      session.run_async
+      session.app.update
+
+      session[:settings].show
+      session.app.update
+
+      assert_equal '', session.app.tcl_eval("grab current #{session[:settings].path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_hide_releases_the_grab_for_a_modal_window
+    assert_tk_app("hide should release the grab a modal show set") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.window(:settings, modal: true) }
+      session.run_async
+      session.app.update
+
+      session[:settings].show
+      session.app.update
+      path = session[:settings].path
+      assert_equal path, session.app.tcl_eval("grab current #{path}")
+
+      session[:settings].hide
+      session.app.update
+      assert_equal '', session.app.tcl_eval("grab current #{path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_dialog_defaults_to_modal_and_non_resizable
+    assert_tk_app("ui.dialog should default to modal: true, resizable: false") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.dialog(:confirm) }
+      session.run_async
+      session.app.update
+
+      path = session[:confirm].path
+      assert_equal :window, session[:confirm].type
+      assert_equal '0 0', session.app.tcl_eval("wm resizable #{path}")
+
+      session[:confirm].show
+      session.app.update
+      assert_equal path, session.app.tcl_eval("grab current #{path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_dialog_defaults_are_overridable
+    assert_tk_app("ui.dialog's modal:/resizable: defaults should still be overridable") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') do |ui|
+        ui.dialog(:confirm, modal: false, resizable: true)
+      end
+      session.run_async
+      session.app.update
+
+      path = session[:confirm].path
+      assert_equal '1 1', session.app.tcl_eval("wm resizable #{path}")
+
+      session[:confirm].show
+      session.app.update
+      assert_equal '', session.app.tcl_eval("grab current #{path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_show_and_hide_raise_on_a_non_window_handle
+    assert_tk_app("show/hide on a non-window handle should raise a clear error") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Managed Window Test') { |ui| ui.button(:go, text: 'Go') }
+      session.run_async
+      session.app.update
+
+      show_error = assert_raises(ArgumentError) { session[:go].show }
+      assert_match(/window/i, show_error.message)
+
+      hide_error = assert_raises(ArgumentError) { session[:go].hide }
+      assert_match(/window/i, hide_error.message)
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_menu_dsl.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'teek/ui/session'
+
+class TestMenuDsl < Minitest::Test
+  def build_session
+    Teek::UI::Session.new(title: 'Menu DSL Test')
+  end
+
+  def test_menu_bar_creates_a_menu_bar_node_at_the_top_level
+    session = build_session
+
+    handle = session.menu_bar { |mb| mb.menu(label: 'File') }
+
+    node = session.document.root.children.first
+    assert_equal :menu_bar, node.type
+    assert_kind_of Teek::UI::Handle, handle
+    assert_equal :menu_bar, handle.type
+  end
+
+  def test_menu_bar_is_addressable_when_named
+    session = build_session
+
+    session.menu_bar(:mb) { |mb| mb.menu(label: 'File') }
+
+    handle = session[:mb]
+    assert_kind_of Teek::UI::Handle, handle
+    assert_equal :menu_bar, handle.type
+  end
+
+  def test_menu_bar_raises_when_declared_inside_a_regular_container
+    session = build_session
+
+    error = assert_raises(ArgumentError) do
+      session.panel(:p) { |p| p.menu_bar { |mb| mb.menu(label: 'File') } }
+    end
+    assert_match(/menu_bar/, error.message)
+  end
+
+  def test_menu_bar_is_allowed_directly_inside_a_window
+    session = build_session
+
+    session.window(:settings) { |w| w.menu_bar { |mb| mb.menu(label: 'File') } }
+
+    window_node = session.document.root.children.first
+    menu_bar_node = window_node.children.first
+    assert_equal :menu_bar, menu_bar_node.type
+  end
+
+  def test_menu_declares_a_nested_cascade_node_with_a_label
+    session = build_session
+
+    session.menu_bar { |mb| mb.menu(label: 'File') }
+
+    menu_bar_node = session.document.root.children.first
+    file_node = menu_bar_node.children.first
+    assert_equal :menu, file_node.type
+    assert_equal 'File', file_node.opts[:label]
+  end
+
+  def test_menu_is_addressable_when_named
+    session = build_session
+
+    session.menu_bar { |mb| mb.menu(:file, label: 'File') }
+
+    handle = session[:file]
+    assert_kind_of Teek::UI::Handle, handle
+    assert_equal :menu, handle.type
+  end
+
+  def test_menu_nests_recursively_for_submenus
+    session = build_session
+
+    session.menu_bar do |mb|
+      mb.menu(label: 'File') do |file|
+        file.menu(:recent, label: 'Recent') do |recent|
+          recent.item(label: 'doc1.txt') { }
+        end
+      end
+    end
+
+    file_node = session.document.root.children.first.children.first
+    recent_node = file_node.children.first
+    assert_equal :menu, recent_node.type
+    assert_equal 'Recent', recent_node.opts[:label]
+    assert_equal [:menu_item], recent_node.children.map(&:type)
+  end
+
+  def test_item_appends_a_command_entry_with_a_command_block
+    session = build_session
+    fired = false
+
+    session.menu_bar { |mb| mb.menu(label: 'File') { |f| f.item(label: 'Open') { fired = true } } }
+
+    item_node = session.document.root.children.first.children.first.children.first
+    assert_equal :menu_item, item_node.type
+    assert_equal 'Open', item_node.opts[:label]
+    item_node.opts[:command].call
+    assert fired, "the item's block should be stashed as opts[:command]"
+  end
+
+  def test_item_is_addressable_when_named
+    session = build_session
+
+    session.menu_bar { |mb| mb.menu(label: 'File') { |f| f.item(:quick_load, label: 'Quick Load') { } } }
+
+    handle = session[:quick_load]
+    assert_kind_of Teek::UI::Handle, handle
+    assert_equal :menu_item, handle.type
+  end
+
+  def test_item_returns_a_handle_even_when_unnamed
+    session = build_session
+    handle = nil
+
+    session.menu_bar { |mb| mb.menu(label: 'File') { |f| handle = f.item(label: 'Open') { } } }
+
+    assert_kind_of Teek::UI::Handle, handle
+  end
+
+  def test_item_without_a_block_has_no_command_opt
+    session = build_session
+
+    session.menu_bar { |mb| mb.menu(label: 'File') { |f| f.item(label: 'Disabled') } }
+
+    item_node = session.document.root.children.first.children.first.children.first
+    refute item_node.opts.key?(:command)
+  end
+
+  def test_item_passes_through_extra_opts_like_accelerator
+    session = build_session
+
+    session.menu_bar { |mb| mb.menu(label: 'File') { |f| f.item(label: 'Save', accelerator: 'Ctrl+S') { } } }
+
+    item_node = session.document.root.children.first.children.first.children.first
+    assert_equal 'Ctrl+S', item_node.opts[:accelerator]
+  end
+
+  def test_separator_appends_a_separator_entry
+    session = build_session
+
+    session.menu_bar { |mb| mb.menu(label: 'File') { |f| f.separator } }
+
+    node = session.document.root.children.first.children.first.children.first
+    assert_equal :menu_separator, node.type
+    assert_equal({}, node.opts)
+  end
+
+  def test_checkbox_appends_a_checkbutton_entry_bound_to_a_var
+    session = build_session
+    wrap = session.var(true)
+
+    session.menu_bar { |mb| mb.menu(label: 'Edit') { |e| e.checkbox(label: 'Word Wrap', bind: wrap) } }
+
+    node = session.document.root.children.first.children.first.children.first
+    assert_equal :menu_checkbox, node.type
+    assert_equal 'Word Wrap', node.opts[:label]
+    assert_same wrap, node.opts[:bind]
+  end
+
+  def test_checkbox_is_addressable_when_named
+    session = build_session
+    wrap = session.var(true)
+
+    session.menu_bar { |mb| mb.menu(label: 'Edit') { |e| e.checkbox(:word_wrap, label: 'Word Wrap', bind: wrap) } }
+
+    handle = session[:word_wrap]
+    assert_kind_of Teek::UI::Handle, handle
+    assert_equal :menu_checkbox, handle.type
+  end
+
+  def test_radio_is_addressable_when_named
+    session = build_session
+    size = session.var('small')
+
+    session.menu_bar { |mb| mb.menu(label: 'Edit') { |e| e.radio(:small_size, label: 'Small', bind: size, value: 'small') } }
+
+    handle = session[:small_size]
+    assert_kind_of Teek::UI::Handle, handle
+    assert_equal :menu_radio, handle.type
+  end
+
+  def test_radio_appends_a_radiobutton_entry_bound_to_a_var_with_a_value
+    session = build_session
+    size = session.var('small')
+
+    session.menu_bar { |mb| mb.menu(label: 'Edit') { |e| e.radio(label: 'Small', bind: size, value: 'small') } }
+
+    node = session.document.root.children.first.children.first.children.first
+    assert_equal :menu_radio, node.type
+    assert_equal 'small', node.opts[:value]
+    assert_same size, node.opts[:bind]
+  end
+
+  def test_context_menu_creates_a_context_menu_node
+    session = build_session
+
+    handle = session.context_menu(:ctx) { |m| m.item(label: 'Delete') { } }
+
+    node = session.document.root.children.first
+    assert_equal :context_menu, node.type
+    assert_kind_of Teek::UI::Handle, handle
+    assert_equal :ctx, handle.name
+  end
+
+  def test_context_menu_can_hold_submenus_and_entries_like_any_menu
+    session = build_session
+
+    session.context_menu(:ctx) do |m|
+      m.item(label: 'Delete') { }
+      m.menu(label: 'Send to') { |sm| sm.item(label: 'Archive') { } }
+    end
+
+    ctx_node = session.document.root.children.first
+    assert_equal %i[menu_item menu], ctx_node.children.map(&:type)
+  end
+
+  def test_menu_builder_does_not_expose_ordinary_widget_methods
+    session = build_session
+
+    session.menu_bar do |mb|
+      # MenuBuilder is a distinct vocabulary, not the top-level widget DSL -
+      # #checkbox/#radio here mean menu entries, not ttk::checkbutton/
+      # ttk::radiobutton widgets, so it must not carry those methods too.
+      refute mb.respond_to?(:button), "MenuBuilder should not carry the top-level widget vocabulary"
+      assert mb.respond_to?(:checkbox), "MenuBuilder should define its own (menu-flavored) #checkbox"
+    end
+  end
+end

data/test/test_menu_entry_addressing.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+require 'teek/ui/node'
+require 'teek/ui/realized_node'
+require 'teek/ui/menu_entry_addressing'
+
+# MenuEntryAddressing is the WidgetType#addressing strategy for :menu_item/
+# :menu_checkbox/:menu_radio - a menu entry has no independent Tk path of
+# its own, only the enclosing menu does, so this resolves the entry's
+# CURRENT position fresh on every call via Node#parent instead of caching
+# an index (Tk menu entries are addressed purely by numeric index, and
+# TkMenu.c renumbers every entry after the one that changed).
+class TestMenuEntryAddressing < Minitest::Test
+  include TeekTestHelper
+
+  def test_virtual_path_marks_past_the_real_tk_path
+    menu_node = Teek::UI::Node.new(type: :menu, name: :file_menu)
+    menu_node.realized = Teek::UI::RealizedNode.new(app: :fake_app, path: '.menu_bar.file_menu')
+    entry = menu_node.add_child(Teek::UI::Node.new(type: :menu_item, name: :quick_load))
+
+    addressing = Teek::UI::MenuEntryAddressing.new(entry)
+
+    assert_equal '.menu_bar.file_menu!quick_load', addressing.virtual_path
+  end
+
+  def test_configure_raises_before_the_parent_menu_is_realized
+    menu_node = Teek::UI::Node.new(type: :menu, name: :file_menu)
+    entry = menu_node.add_child(Teek::UI::Node.new(type: :menu_item, name: :quick_load))
+
+    addressing = Teek::UI::MenuEntryAddressing.new(entry)
+
+    assert_raises(Teek::UI::NotRealizedError) { addressing.configure(state: :disabled) }
+  end
+
+  def test_configure_targets_the_live_current_index_immune_to_earlier_sibling_removal
+    assert_tk_app("configure should entryconfigure the entry at its CURRENT live index, not a stale cached one") do
+      require 'teek/ui/node'
+      require 'teek/ui/realized_node'
+      require 'teek/ui/menu_entry_addressing'
+
+      menu_path = '.testmenu1'
+      app.menu(menu_path)
+      app.command(menu_path, :add, :command, label: 'First')
+      app.command(menu_path, :add, :command, label: 'Second')
+      app.command(menu_path, :add, :command, label: 'Third')
+
+      menu_node = Teek::UI::Node.new(type: :menu, name: :testmenu1)
+      menu_node.realized = Teek::UI::RealizedNode.new(app: app, path: menu_path)
+
+      first_entry = menu_node.add_child(Teek::UI::Node.new(type: :menu_item, name: :first))
+      menu_node.add_child(Teek::UI::Node.new(type: :menu_item, name: :second))
+      third_entry = menu_node.add_child(Teek::UI::Node.new(type: :menu_item, name: :third))
+
+      # Removing First shifts Second and Third down one live index each -
+      # Tk itself renumbers around the delete; nothing in teek does the
+      # shifting. Node#parent.children.index(node) just re-reads whatever
+      # the CURRENT position is, so it's automatically correct with no
+      # bookkeeping - a stale index cached at creation time (2, for Third)
+      # would now be wrong.
+      app.command(menu_path, :delete, 0)
+      menu_node.children.delete(first_entry)
+
+      Teek::UI::MenuEntryAddressing.new(third_entry).configure(state: :disabled)
+
+      assert_equal 'disabled', app.tcl_eval("#{menu_path} entrycget 1 -state"),
+        "Third's live index is now 1 (after First was removed) - entry 1 should be disabled"
+      assert_equal 'normal', app.tcl_eval("#{menu_path} entrycget 0 -state"),
+        "Second's live index is now 0 - it should be untouched"
+    end
+  end
+end