gemba 0.1.1 → 0.2.0

data/test/{test_rom_loader.rb → test_rom_resolver.rb}

@@ -5,40 +5,39 @@ require "gemba"
 require "tmpdir"
 require "zip"
 
-class TestRomLoader < Minitest::Test
+class TestRomResolver < Minitest::Test
   TEST_ROM = File.expand_path("fixtures/test.gba", __dir__)
 
   def setup
-    skip "Run: ruby gemba/scripts/generate_test_rom.rb" unless File.exist?(TEST_ROM)
     @tmpdir = Dir.mktmpdir("rom_loader_test")
   end
 
   def teardown
     FileUtils.rm_rf(@tmpdir) if @tmpdir && File.directory?(@tmpdir)
-    Gemba::RomLoader.cleanup_temp
+    Gemba::RomResolver.cleanup_temp
   end
 
   # -- resolve passthrough --
 
   def test_resolve_gba_returns_path_unchanged
-    assert_equal TEST_ROM, Gemba::RomLoader.resolve(TEST_ROM)
+    assert_equal TEST_ROM, Gemba::RomResolver.resolve(TEST_ROM)
   end
 
   def test_resolve_gb_returns_path_unchanged
     path = "/some/game.gb"
-    assert_equal path, Gemba::RomLoader.resolve(path)
+    assert_equal path, Gemba::RomResolver.resolve(path)
   end
 
   def test_resolve_gbc_returns_path_unchanged
     path = "/some/game.gbc"
-    assert_equal path, Gemba::RomLoader.resolve(path)
+    assert_equal path, Gemba::RomResolver.resolve(path)
   end
 
   # -- resolve from zip --
 
   def test_resolve_zip_extracts_rom
     zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
-    result = Gemba::RomLoader.resolve(zip_path)
+    result = Gemba::RomResolver.resolve(zip_path)
 
     assert File.exist?(result), "extracted ROM should exist"
     assert_equal ".gba", File.extname(result).downcase
@@ -47,7 +46,7 @@ class TestRomLoader < Minitest::Test
 
   def test_resolve_zip_loads_in_core
     zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
-    rom_path = Gemba::RomLoader.resolve(zip_path)
+    rom_path = Gemba::RomResolver.resolve(zip_path)
 
     core = Gemba::Core.new(rom_path)
     assert_equal "GEMBATEST", core.title
@@ -60,8 +59,8 @@ class TestRomLoader < Minitest::Test
   def test_resolve_zip_no_rom_raises
     zip_path = create_zip("empty.zip", "readme.txt" => "hello")
 
-    err = assert_raises(Gemba::RomLoader::NoRomInZip) do
-      Gemba::RomLoader.resolve(zip_path)
+    err = assert_raises(Gemba::RomResolver::NoRomInZip) do
+      Gemba::RomResolver.resolve(zip_path)
     end
     assert_includes err.message, "empty.zip"
   end
@@ -72,15 +71,15 @@ class TestRomLoader < Minitest::Test
       "game1.gba" => rom_data,
       "game2.gba" => rom_data)
 
-    err = assert_raises(Gemba::RomLoader::MultipleRomsInZip) do
-      Gemba::RomLoader.resolve(zip_path)
+    err = assert_raises(Gemba::RomResolver::MultipleRomsInZip) do
+      Gemba::RomResolver.resolve(zip_path)
     end
     assert_includes err.message, "multi.zip"
   end
 
   def test_resolve_unsupported_extension_raises
-    assert_raises(Gemba::RomLoader::UnsupportedFormat) do
-      Gemba::RomLoader.resolve("/some/file.rar")
+    assert_raises(Gemba::RomResolver::UnsupportedFormat) do
+      Gemba::RomResolver.resolve("/some/file.rar")
     end
   end
 
@@ -88,8 +87,8 @@ class TestRomLoader < Minitest::Test
     corrupt = File.join(@tmpdir, "corrupt.zip")
     File.binwrite(corrupt, "this is not a zip file")
 
-    assert_raises(Gemba::RomLoader::ZipReadError) do
-      Gemba::RomLoader.resolve(corrupt)
+    assert_raises(Gemba::RomResolver::ZipReadError) do
+      Gemba::RomResolver.resolve(corrupt)
     end
   end
 
@@ -102,32 +101,32 @@ class TestRomLoader < Minitest::Test
       zos.write(File.binread(TEST_ROM))
     end
 
-    assert_raises(Gemba::RomLoader::NoRomInZip) do
-      Gemba::RomLoader.resolve(zip_path)
+    assert_raises(Gemba::RomResolver::NoRomInZip) do
+      Gemba::RomResolver.resolve(zip_path)
     end
   end
 
   # -- constants --
 
   def test_rom_extensions
-    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gba"
-    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gb"
-    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gbc"
+    assert_includes Gemba::RomResolver::ROM_EXTENSIONS, ".gba"
+    assert_includes Gemba::RomResolver::ROM_EXTENSIONS, ".gb"
+    assert_includes Gemba::RomResolver::ROM_EXTENSIONS, ".gbc"
   end
 
   def test_supported_extensions_includes_zip
-    assert_includes Gemba::RomLoader::SUPPORTED_EXTENSIONS, ".zip"
+    assert_includes Gemba::RomResolver::SUPPORTED_EXTENSIONS, ".zip"
   end
 
   # -- cleanup --
 
   def test_cleanup_temp_removes_directory
     zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
-    Gemba::RomLoader.resolve(zip_path)
-    assert File.directory?(Gemba::RomLoader.tmp_dir)
+    Gemba::RomResolver.resolve(zip_path)
+    assert File.directory?(Gemba::RomResolver.tmp_dir)
 
-    Gemba::RomLoader.cleanup_temp
-    refute File.directory?(Gemba::RomLoader.tmp_dir)
+    Gemba::RomResolver.cleanup_temp
+    refute File.directory?(Gemba::RomResolver.tmp_dir)
   end
 
   private

data/test/test_save_state_manager.rb

@@ -3,9 +3,7 @@
 require "minitest/autorun"
 require "tmpdir"
 require "json"
-require_relative "../lib/gemba/config"
-require_relative "../lib/gemba/locale"
-require_relative "../lib/gemba/save_state_manager"
+require "gemba/headless"
 
 class TestSaveStateManager < Minitest::Test
   # Recording mock for the mGBA Core.
@@ -92,7 +90,7 @@ class TestSaveStateManager < Minitest::Test
   end
 
   def new_manager(core: @core, config: @config, app: @app)
-    mgr = Gemba::SaveStateManager.new(core: core, config: config, app: app)
+    mgr = Gemba::SaveStateManager.new(core: core, config: config, app: app, platform: Gemba::Platform.default)
     mgr.state_dir = mgr.state_dir_for_rom(core)
     mgr
   end

data/test/test_settings_audio.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+
+class TestSettingsAudioTab < Minitest::Test
+  include TeekTestHelper
+
+  # -- Volume slider ------------------------------------------------------
+
+  def test_volume_defaults_to_100
+    assert_tk_app("volume defaults to 100") do
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      assert_equal '100', app.get_variable(Gemba::Settings::AudioTab::VAR_VOLUME)
+    end
+  end
+
+  def test_dragging_volume_to_50_fires_callback
+    assert_tk_app("dragging volume to 50 fires on_volume_change") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:volume_changed) { |v| received = v }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      # Simulate user dragging volume slider to 50
+      app.command(Gemba::Settings::AudioTab::VOLUME_SCALE, 'set', 50)
+      app.update
+
+      assert_in_delta 0.5, received, 0.01
+    end
+  end
+
+  def test_volume_at_zero
+    assert_tk_app("volume at zero") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:volume_changed) { |v| received = v }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      app.command(Gemba::Settings::AudioTab::VOLUME_SCALE, 'set', 0)
+      app.update
+
+      assert_in_delta 0.0, received, 0.01
+    end
+  end
+
+  # -- Mute checkbox ------------------------------------------------------
+
+  def test_mute_defaults_to_off
+    assert_tk_app("mute defaults to off") do
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      assert_equal '0', app.get_variable(Gemba::Settings::AudioTab::VAR_MUTE)
+    end
+  end
+
+  def test_clicking_mute_fires_callback
+    assert_tk_app("clicking mute fires on_mute_change") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:mute_changed) { |m| received = m }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      # Simulate user clicking the mute checkbox
+      app.command(Gemba::Settings::AudioTab::MUTE_CHECK, 'invoke')
+      app.update
+
+      assert_equal true, received
+    end
+  end
+
+  def test_clicking_mute_twice_unmutes
+    assert_tk_app("clicking mute twice unmutes") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:mute_changed) { |m| received = m }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      app.command(Gemba::Settings::AudioTab::MUTE_CHECK, 'invoke')
+      app.update
+      assert_equal true, received
+
+      app.command(Gemba::Settings::AudioTab::MUTE_CHECK, 'invoke')
+      app.update
+      assert_equal false, received
+    end
+  end
+end

data/test/test_settings_hotkeys.rb

@@ -8,9 +8,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_hotkeys_tab_exists
     assert_tk_app("hotkeys tab exists in notebook") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -21,9 +21,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_hotkey_buttons_show_default_keysyms
     assert_tk_app("hotkey buttons show default keysyms") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -40,9 +40,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_clicking_hotkey_button_enters_listen_mode
     assert_tk_app("clicking hotkey button enters listen mode") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -57,13 +57,13 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_capture_updates_label_and_fires_callback
     assert_tk_app("capturing hotkey updates label and fires callback") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received_action = nil
       received_key = nil
-      sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |a, k| received_action = a; received_key = k }
-      })
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |a, k| received_action = a; received_key = k }
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -85,9 +85,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_capture_enables_undo_button
     assert_tk_app("capturing hotkey enables undo button") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -108,12 +108,12 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_undo_fires_callback_and_disables
     assert_tk_app("undo fires on_undo_hotkeys and disables button") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       undo_called = false
-      sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_undo_hotkeys: proc { undo_called = true }
-      })
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:undo_hotkeys) { undo_called = true }
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -135,11 +135,12 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_reset_restores_defaults
     assert_tk_app("reset restores default hotkey labels") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       reset_called = false
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_reset) { reset_called = true }
       sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_reset: proc { reset_called = true },
         on_confirm_reset_hotkeys: -> { true },
       })
       sw.show
@@ -168,9 +169,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_refresh_hotkeys_updates_labels
     assert_tk_app("refresh_hotkeys updates button labels") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -187,9 +188,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_cancel_listen_restores_label
     assert_tk_app("canceling listen restores original label") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -210,12 +211,12 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_capture_without_listen_is_noop
     assert_tk_app("capture without listen mode is a no-op") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received = false
-      sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |*| received = true }
-      })
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |*| received = true }
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -233,12 +234,13 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_hotkey_rejected_when_conflicting_with_gamepad_key
     assert_tk_app("hotkey rejected when key conflicts with gamepad mapping") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received = false
       conflict_msg = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |*| received = true }
       sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |*| received = true },
         on_validate_hotkey: ->(keysym) {
           # Simulate: 'z' is GBA button A
           keysym == 'z' ? '"z" is mapped to GBA button A' : nil
@@ -265,11 +267,12 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_hotkey_accepted_when_no_conflict
     assert_tk_app("hotkey accepted when no conflict") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received_action = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |a, _| received_action = a }
       sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |a, _| received_action = a },
         on_validate_hotkey: ->(_) { nil },
       })
       sw.show
@@ -290,13 +293,13 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_capture_modifier_then_key_produces_combo
     assert_tk_app("modifier + key produces combo hotkey") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received_action = nil
       received_hk = nil
-      sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |a, hk| received_action = a; received_hk = hk },
-      })
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |a, hk| received_action = a; received_hk = hk }
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -319,12 +322,12 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_capture_multi_modifier_combo
     assert_tk_app("multi-modifier combo (Ctrl+Shift+S)") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received_hk = nil
-      sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |_, hk| received_hk = hk },
-      })
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |_, hk| received_hk = hk }
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -344,11 +347,12 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_combo_hotkey_skips_gamepad_conflict_validation
     assert_tk_app("combo hotkey skips gamepad conflict validation") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received_hk = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |_, hk| received_hk = hk }
       sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |_, hk| received_hk = hk },
         # 'z' conflicts as a plain key, but Ctrl+z should be fine
         on_validate_hotkey: ->(key) {
           key == 'z' ? '"z" is mapped to GBA button A' : nil
@@ -370,9 +374,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_refresh_hotkeys_shows_combo_display_name
     assert_tk_app("refresh_hotkeys shows combo display name") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -387,12 +391,12 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_bind_script_modifier_combo_roundtrip
     assert_tk_app("Tcl bind script round-trip with modifier+key combo") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
+      require "gemba/headless"
+      require "gemba/headless"
       received_hk = nil
-      sw = Gemba::SettingsWindow.new(app, callbacks: {
-        on_hotkey_change: proc { |_, hk| received_hk = hk },
-      })
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:hotkey_changed) { |_, hk| received_hk = hk }
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -421,9 +425,9 @@ class TestMGBASettingsHotkeys < Minitest::Test
 
   def test_record_hotkey_button_shows_default
     assert_tk_app("record hotkey button shows F10") do
-      require "gemba/settings_window"
-      require "gemba/hotkey_map"
-      sw = Gemba::SettingsWindow.new(app, callbacks: {})
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
       sw.show
       app.update
 
@@ -431,4 +435,17 @@ class TestMGBASettingsHotkeys < Minitest::Test
       assert_equal 'F10', text
     end
   end
+
+  def test_open_rom_hotkey_button_shows_default
+    assert_tk_app("open rom hotkey button shows Ctrl+O") do
+      require "gemba/headless"
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      text = app.command(Gemba::SettingsWindow::HK_ACTIONS[:open_rom], 'cget', '-text')
+      assert_equal 'Ctrl+O', text
+    end
+  end
 end

data/test/test_settings_recording.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+
+class TestSettingsRecordingTab < Minitest::Test
+  include TeekTestHelper
+
+  def test_recording_tab_exists
+    assert_tk_app("recording tab exists in notebook") do
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      tabs = app.command(Gemba::Settings::Paths::NB, 'tabs')
+      assert_includes tabs, Gemba::Settings::RecordingTab::FRAME
+    end
+  end
+
+  def test_compression_combobox_defaults_to_1
+    assert_tk_app("compression combobox defaults to 1") do
+      require "gemba/headless"
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      assert_equal '1', app.get_variable(Gemba::Settings::RecordingTab::VAR_COMPRESSION)
+    end
+  end
+
+  def test_selecting_compression_fires_callback
+    assert_tk_app("selecting compression fires on_compression_change") do
+      require "gemba/headless"
+      received = nil
+      Gemba.bus = Gemba::EventBus.new
+      Gemba.bus.on(:compression_changed) { |v| received = v }
+      sw = Gemba::SettingsWindow.new(app)
+      sw.show
+      app.update
+
+      app.set_variable(Gemba::Settings::RecordingTab::VAR_COMPRESSION, '6')
+      app.command(:event, 'generate', Gemba::Settings::RecordingTab::COMPRESSION_COMBO, '<<ComboboxSelected>>')
+      app.update
+
+      assert_equal 6, received
+    end
+  end
+end