teek-ui 0.1.0

data/test/test_modal_stack_realtk.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# Real-Tk half of ModalStack's coverage - the callback lifecycle (on_enter/
+# on_exit/on_focus_change) is covered headlessly in test_modal_stack.rb;
+# these exercise the actual show/hide/grab side effects against real
+# ui.dialog windows.
+class TestModalStackRealTk < Minitest::Test
+  include TeekTestHelper
+
+  def test_push_shows_and_grabs_the_dialog
+    assert_tk_app("pushing a modal dialog should map and grab it") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'ModalStack Test') { |ui| ui.dialog(:settings) }
+      session.run_async
+      session.app.update
+
+      session.modal = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { })
+      session.modal.push(:settings, session[:settings])
+      session.app.update
+
+      path = session[:settings].path
+      assert session.app.winfo.ismapped?(path)
+      assert_equal path, session.app.tcl_eval("grab current #{path}")
+
+      session.app.destroy
+    end
+  end
+
+  def test_pushing_a_second_dialog_withdraws_the_first_and_grabs_the_second
+    assert_tk_app("pushing a second dialog should withdraw/release the first and grab the second") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'ModalStack Test') do |ui|
+        ui.dialog(:settings)
+        ui.dialog(:replay)
+      end
+      session.run_async
+      session.app.update
+
+      session.modal = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { })
+      session.modal.push(:settings, session[:settings])
+      session.app.update
+      session.modal.push(:replay, session[:replay])
+      session.app.update
+
+      settings_path = session[:settings].path
+      replay_path = session[:replay].path
+
+      refute session.app.winfo.ismapped?(settings_path)
+      assert session.app.winfo.ismapped?(replay_path)
+      assert_equal replay_path, session.app.tcl_eval("grab current #{replay_path}")
+      assert_equal :replay, session.modal.current
+      assert_equal 2, session.modal.size
+
+      session.app.destroy
+    end
+  end
+
+  def test_pop_re_shows_and_re_grabs_the_dialog_underneath
+    assert_tk_app("popping the top dialog should re-show and re-grab the one underneath") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'ModalStack Test') do |ui|
+        ui.dialog(:settings)
+        ui.dialog(:replay)
+      end
+      session.run_async
+      session.app.update
+
+      session.modal = Teek::UI::ModalStack.new(on_enter: ->(_) { }, on_exit: -> { })
+      session.modal.push(:settings, session[:settings])
+      session.modal.push(:replay, session[:replay])
+      session.app.update
+
+      session.modal.pop
+      session.app.update
+
+      settings_path = session[:settings].path
+      replay_path = session[:replay].path
+
+      assert session.app.winfo.ismapped?(settings_path)
+      refute session.app.winfo.ismapped?(replay_path)
+      assert_equal settings_path, session.app.tcl_eval("grab current #{settings_path}")
+      assert_equal :settings, session.modal.current
+
+      session.app.destroy
+    end
+  end
+
+  def test_the_on_enter_and_on_exit_callbacks_bracket_a_whole_modal_session
+    assert_tk_app("on_enter should fire on the first push, on_exit on the last pop") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'ModalStack Test') do |ui|
+        ui.dialog(:settings)
+        ui.dialog(:replay)
+      end
+      session.run_async
+      session.app.update
+
+      events = []
+      session.modal = Teek::UI::ModalStack.new(
+        on_enter: ->(name) { events << [:enter, name] },
+        on_exit: -> { events << [:exit] },
+        on_focus_change: ->(name) { events << [:focus, name] },
+      )
+
+      session.modal.push(:settings, session[:settings])
+      session.modal.push(:replay, session[:replay])
+      session.app.update
+      session.modal.pop
+      session.modal.pop
+      session.app.update
+
+      assert_equal [
+        [:enter, :settings],
+        [:focus, :settings],
+        [:focus, :replay],
+        [:focus, :settings],
+        [:exit],
+      ], events
+      refute session.modal.active?
+
+      session.app.destroy
+    end
+  end
+end

data/test/test_native_scrollable.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../../test/tk_test_helper'
+
+# A bare list/text_area/table/tree/canvas auto-attaches a scrollbar
+# wherever it's declared - no ui.scrollable wrapper needed. See
+# Realizer#create_native_scrollable/#auto_scrollable?/#resolve_scroll.
+#
+# The widget is wrapped in an invisible frame (widget + scrollbar,
+# gridded together) that takes over the node's own allocated path; the
+# real widget lives one level deeper, at <path>.widget, which is what
+# session[:name].path/.configure/events all still act on directly - see
+# RealizedNode's arrange_path split. Validation that scroll: raises on an
+# unsupported widget type is headless, in test_widget_dsl.rb.
+class TestNativeScrollable < Minitest::Test
+  include TeekTestHelper
+
+  def test_a_bare_list_auto_attaches_a_vertical_scrollbar_by_default
+    assert_tk_app("ui.list should get a scrollbar with no ui.scrollable wrapper") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') { |ui| ui.list(:items) }
+      session.run_async
+      session.app.update
+
+      list_path = session[:items].path
+      wrapper_path = list_path.sub(/\.widget\z/, '')
+      vsb_path = "#{wrapper_path}.vsb"
+
+      refute_equal wrapper_path, list_path, "the handle path should be the real widget, not the wrapper"
+      assert_equal '1', session.app.tcl_eval("winfo exists #{vsb_path}")
+      assert_equal '0', session.app.tcl_eval("winfo exists #{wrapper_path}.hsb"), "x: defaults to false"
+      assert_equal "#{list_path} yview", session.app.command(vsb_path, :cget, '-command')
+
+      session.app.destroy
+    end
+  end
+
+  def test_configure_and_events_act_on_the_real_widget_not_the_wrapper
+    assert_tk_app("Handle#configure/#on_click should still act on the real widget once auto-wrapped") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') { |ui| ui.list(:items) }
+      session.run_async
+      session.app.update
+
+      clicked = false
+      session[:items].on_click { clicked = true }
+      session[:items].configure(exportselection: false)
+      session.app.update
+
+      assert_equal '0', session.app.command(session[:items].path, :cget, '-exportselection')
+
+      session.app.tcl_eval("event generate #{session[:items].path} <Button-1>")
+      session.app.update
+
+      assert clicked
+
+      session.app.destroy
+    end
+  end
+
+  def test_scroll_false_opts_out_leaving_a_plain_unwrapped_widget
+    assert_tk_app("scroll: false should leave the widget exactly as it was before auto-scroll existed") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') do |ui|
+        ui.column(:panel) { |c| c.list(:items, scroll: false) }
+      end
+      session.run_async
+      session.app.update
+
+      assert_equal "#{session[:panel].path}.items", session[:items].path
+      assert_equal '0', session.app.tcl_eval("winfo exists #{session[:items].path}.vsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_text_area_and_table_and_tree_also_auto_attach
+    assert_tk_app("text_area/table/tree should get the same auto-attach treatment as list") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') do |ui|
+        ui.text_area(:notes)
+        ui.table(:grid_view)
+        ui.tree(:hierarchy)
+      end
+      session.run_async
+      session.app.update
+
+      %i[notes grid_view hierarchy].each do |name|
+        wrapper = session[name].path.sub(/\.widget\z/, '')
+        assert_equal '1', session.app.tcl_eval("winfo exists #{wrapper}.vsb"), "#{name} should have auto-attached a scrollbar"
+      end
+
+      session.app.destroy
+    end
+  end
+
+  def test_canvas_defaults_to_no_auto_attach
+    assert_tk_app("canvas should default to scroll: false, unlike the other native types") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') { |ui| ui.canvas(:board) }
+      session.run_async
+      session.app.update
+
+      assert_equal '.board', session[:board].path
+      assert_equal '0', session.app.tcl_eval("winfo exists .board.vsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_canvas_scroll_true_forces_it_on
+    assert_tk_app("scroll: true should override canvas's own false default") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') { |ui| ui.canvas(:board, scroll: true) }
+      session.run_async
+      session.app.update
+
+      wrapper = session[:board].path.sub(/\.widget\z/, '')
+      assert_equal '1', session.app.tcl_eval("winfo exists #{wrapper}.vsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_canvas_children_still_create_inside_the_real_canvas_once_wrapped
+    assert_tk_app("a canvas's own DSL children (via ui.raw) should target the real canvas, not the wrapper") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') do |ui|
+        # ui.canvas's own block yields the builder itself (not a scoped
+        # Handle - see WidgetDSL's own doc comment), so the real canvas
+        # handle is looked up by name via the outer `ui` instead.
+        ui.canvas(:board, scroll: true) { |c| c.raw { |app| app.command(ui[:board].path, :create, :text, 10, 10, text: 'hi') } }
+      end
+      session.run_async
+      session.app.update
+
+      item_ids = session.app.split_list(session.app.command(session[:board].path, :find, :all))
+      assert_equal 1, item_ids.length
+
+      session.app.destroy
+    end
+  end
+
+  def test_x_true_wires_a_horizontal_scrollbar_on_a_native_widget_too
+    assert_tk_app("x: true on a bare native widget should wire a horizontal scrollbar") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') { |ui| ui.tree(:hierarchy, x: true) }
+      session.run_async
+      session.app.update
+
+      wrapper = session[:hierarchy].path.sub(/\.widget\z/, '')
+      assert_equal '1', session.app.tcl_eval("winfo exists #{wrapper}.hsb")
+      assert_equal "#{session[:hierarchy].path} xview", session.app.command("#{wrapper}.hsb", :cget, '-command')
+
+      session.app.destroy
+    end
+  end
+
+  def test_wrapped_widget_composes_correctly_inside_a_flow_container
+    assert_tk_app("the layout should pack/place the WRAPPER, not the raw widget, inside a flow container") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test') do |ui|
+        ui.column do |c|
+          c.label(text: 'Header')
+          c.list(:items, grow: true)
+        end
+      end
+      session.run_async
+      session.app.update
+
+      wrapper = session[:items].path.sub(/\.widget\z/, '')
+      assert_equal 'pack', session.app.tcl_eval("winfo manager #{wrapper}")
+      assert session.app.winfo.ismapped?(wrapper)
+
+      session.app.destroy
+    end
+  end
+
+  def test_app_level_scroll_false_overrides_the_global_default
+    assert_tk_app("Teek::UI.app(scroll: false) should suppress auto-attach app-wide") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test', scroll: false) { |ui| ui.list(:items) }
+      session.run_async
+      session.app.update
+
+      assert_equal '.items', session[:items].path
+      assert_equal '0', session.app.tcl_eval("winfo exists .items.vsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_per_widget_scroll_true_overrides_an_app_level_false
+    assert_tk_app("a widget's own scroll: true should win over the app-level default") do
+      require 'teek/ui'
+
+      session = Teek::UI.app(title: 'Native Scrollable Test', scroll: false) { |ui| ui.list(:items, scroll: true) }
+      session.run_async
+      session.app.update
+
+      wrapper = session[:items].path.sub(/\.widget\z/, '')
+      assert_equal '1', session.app.tcl_eval("winfo exists #{wrapper}.vsb")
+
+      session.app.destroy
+    end
+  end
+
+  def test_global_default_false_suppresses_auto_attach_unless_overridden
+    assert_tk_app("Teek::UI.auto_scroll = false should suppress the default everywhere it isn't overridden") do
+      require 'teek/ui'
+
+      # The test runner keeps one Tk worker process alive across every test
+      # in this file, reusing its already-loaded Teek::UI module - so a
+      # global class-level default mutated here would otherwise leak into
+      # every test that runs afterward in the same process. Always restore
+      # it, success or failure.
+      original = Teek::UI.auto_scroll
+      begin
+        Teek::UI.auto_scroll = false
+        session = Teek::UI.app(title: 'Native Scrollable Test') do |ui|
+          ui.list(:default_items)
+          ui.list(:forced_items, scroll: true)
+        end
+        session.run_async
+        session.app.update
+
+        assert_equal '.default_items', session[:default_items].path
+        assert_equal '0', session.app.tcl_eval("winfo exists .default_items.vsb")
+
+        forced_wrapper = session[:forced_items].path.sub(/\.widget\z/, '')
+        assert_equal '1', session.app.tcl_eval("winfo exists #{forced_wrapper}.vsb")
+
+        session.app.destroy
+      ensure
+        Teek::UI.auto_scroll = original
+      end
+    end
+  end
+end

data/test/test_node.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require 'teek/ui/node'
+require 'teek/ui/scope'
+
+class TestNode < Minitest::Test
+  def test_defaults
+    node = Teek::UI::Node.new(type: :button)
+
+    assert_equal :button, node.type
+    assert_nil node.name
+    assert_nil node.key
+    assert_equal({}, node.opts)
+    assert_equal [], node.children
+    assert_equal [], node.events
+    assert_nil node.layout
+    assert_nil node.realized
+    assert_same Teek::UI::Scope::TOP_LEVEL, node.scope
+  end
+
+  def test_scope_is_settable_and_readable
+    scope = Teek::UI::Scope.new(:sidebar)
+    node = Teek::UI::Node.new(type: :button, scope: scope)
+
+    assert_same scope, node.scope
+  end
+
+  def test_key_defaults_to_the_name_when_no_key_given
+    node = Teek::UI::Node.new(type: :button, name: :save)
+
+    assert_equal 'save', node.key
+  end
+
+  def test_explicit_key_overrides_the_name_derived_default
+    node = Teek::UI::Node.new(type: :button, name: :save, key: 'custom')
+
+    assert_equal 'custom', node.key
+  end
+
+  def test_opts_are_retained_verbatim
+    node = Teek::UI::Node.new(type: :label, opts: { text: 'Hi', width: 10 })
+
+    assert_equal({ text: 'Hi', width: 10 }, node.opts)
+  end
+
+  def test_add_child_appends_and_returns_the_child
+    parent = Teek::UI::Node.new(type: :column)
+    child = Teek::UI::Node.new(type: :button)
+
+    result = parent.add_child(child)
+
+    assert_equal [child], parent.children
+    assert_same child, result
+  end
+
+  def test_layout_and_realized_are_settable_after_construction
+    node = Teek::UI::Node.new(type: :button)
+
+    node.layout = { grow: true }
+    node.realized = :fake_handle
+
+    assert_equal({ grow: true }, node.layout)
+    assert_equal :fake_handle, node.realized
+  end
+
+  def test_each_visits_self_then_children_depth_first_preorder
+    root = Teek::UI::Node.new(type: :column)
+    a = root.add_child(Teek::UI::Node.new(type: :button, name: :a))
+    b = root.add_child(Teek::UI::Node.new(type: :column, name: :b))
+    c = b.add_child(Teek::UI::Node.new(type: :button, name: :c))
+
+    visited = []
+    root.each { |n| visited << n }
+
+    assert_equal [root, a, b, c], visited
+  end
+
+  def test_each_without_a_block_returns_an_enumerator
+    root = Teek::UI::Node.new(type: :column)
+    root.add_child(Teek::UI::Node.new(type: :button, name: :a))
+
+    assert_equal [:column, :button], root.each.map(&:type)
+  end
+
+  def test_add_child_sets_the_childs_parent
+    parent = Teek::UI::Node.new(type: :column)
+    child = Teek::UI::Node.new(type: :button)
+
+    parent.add_child(child)
+
+    assert_same parent, child.parent
+  end
+
+  def test_document_defaults_to_nil
+    node = Teek::UI::Node.new(type: :button)
+
+    assert_nil node.document
+  end
+
+  def test_document_is_settable_at_construction
+    fake_document = Object.new
+    node = Teek::UI::Node.new(type: :button, document: fake_document)
+
+    assert_same fake_document, node.document
+  end
+
+  def test_remove_child_removes_it_from_the_parents_children
+    parent = Teek::UI::Node.new(type: :column)
+    a = parent.add_child(Teek::UI::Node.new(type: :button, name: :a))
+    b = parent.add_child(Teek::UI::Node.new(type: :button, name: :b))
+
+    parent.remove_child(a)
+
+    assert_equal [b], parent.children
+  end
+
+  def test_remove_child_clears_the_removed_nodes_own_parent
+    parent = Teek::UI::Node.new(type: :column)
+    child = parent.add_child(Teek::UI::Node.new(type: :button))
+
+    parent.remove_child(child)
+
+    assert_nil child.parent
+  end
+
+  def test_remove_child_returns_the_removed_node
+    parent = Teek::UI::Node.new(type: :column)
+    child = parent.add_child(Teek::UI::Node.new(type: :button))
+
+    result = parent.remove_child(child)
+
+    assert_same child, result
+  end
+
+  def test_parent_is_nil_before_being_attached
+    node = Teek::UI::Node.new(type: :button)
+
+    assert_nil node.parent
+  end
+
+  def test_parent_setter_is_not_publicly_callable
+    node = Teek::UI::Node.new(type: :button)
+
+    assert_raises(NoMethodError) { node.parent = Teek::UI::Node.new(type: :column) }
+  end
+
+  def test_root_logical_path_is_a_bare_dot
+    root = Teek::UI::Node.new(type: :root)
+
+    assert_equal '.', root.logical_path
+  end
+
+  def test_logical_path_for_a_top_level_named_node
+    root = Teek::UI::Node.new(type: :root)
+    child = root.add_child(Teek::UI::Node.new(type: :button, name: :save))
+
+    assert_equal '.save', child.logical_path
+  end
+
+  def test_logical_path_nests_through_named_ancestors
+    root = Teek::UI::Node.new(type: :root)
+    column = root.add_child(Teek::UI::Node.new(type: :column, name: :toolbar))
+    button = column.add_child(Teek::UI::Node.new(type: :button, name: :save))
+
+    assert_equal '.toolbar.save', button.logical_path
+  end
+
+  def test_logical_path_uses_the_auto_generated_key_when_unnamed
+    root = Teek::UI::Node.new(type: :root)
+    child = root.add_child(Teek::UI::Node.new(type: :button, key: '#anon1'))
+
+    assert_equal '.#anon1', child.logical_path
+  end
+
+  def test_logical_path_of_an_unattached_node_treats_it_as_top_level
+    node = Teek::UI::Node.new(type: :button, name: :save)
+
+    assert_equal '.save', node.logical_path
+  end
+
+  def test_display_name_is_the_bare_type_when_unnamed
+    node = Teek::UI::Node.new(type: :column)
+
+    assert_equal 'column', node.display_name
+  end
+
+  def test_display_name_includes_the_name_when_given
+    node = Teek::UI::Node.new(type: :column, name: :ctrl)
+
+    assert_equal 'column(:ctrl)', node.display_name
+  end
+end