gemba 0.1.1 → 0.2.0

data/test/test_rom_info.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+
+class TestRomInfo < Minitest::Test
+  # Stub that returns nil for every lookup — isolates RomInfo from real DAT data.
+  NULL_INDEX = Struct.new(:_) {
+    def lookup(_)        = nil
+    def lookup_by_md5(*) = nil
+  }.new(nil)
+
+  ROM = {
+    'rom_id'    => 'AGB_AXVE-DEADBEEF',
+    'title'     => 'Pokemon Ruby',
+    'platform'  => 'gba',
+    'game_code' => 'AGB-AXVE',
+    'path'      => '/games/ruby.gba',
+  }.freeze
+
+  def test_from_rom_sets_basic_fields
+    info = Gemba::RomInfo.from_rom(ROM, game_index: NULL_INDEX)
+    assert_equal 'AGB_AXVE-DEADBEEF', info.rom_id
+    assert_equal 'Pokemon Ruby',       info.title
+    assert_equal 'GBA',                info.platform
+    assert_equal 'AGB-AXVE',           info.game_code
+    assert_equal '/games/ruby.gba',    info.path
+  end
+
+  def test_platform_is_uppercased
+    info = Gemba::RomInfo.from_rom(ROM.merge('platform' => 'gbc'), game_index: NULL_INDEX)
+    assert_equal 'GBC', info.platform
+  end
+
+  def test_title_falls_back_to_rom_id
+    rom  = ROM.merge('title' => nil)
+    info = Gemba::RomInfo.from_rom(rom, game_index: NULL_INDEX)
+    assert_equal 'AGB_AXVE-DEADBEEF', info.title
+  end
+
+  def test_title_from_game_index_wins_over_stored_title
+    index = Struct.new(:_) {
+      def lookup(_)        = 'Index Title'
+      def lookup_by_md5(*) = nil
+    }.new(nil)
+    info = Gemba::RomInfo.from_rom(ROM, game_index: index)
+    assert_equal 'Index Title', info.title
+  end
+
+  def test_no_fetcher_or_overrides_yields_nil_boxart_fields
+    info = Gemba::RomInfo.from_rom(ROM, game_index: NULL_INDEX)
+    assert_nil info.cached_boxart_path
+    assert_nil info.custom_boxart_path
+    assert_nil info.boxart_path
+  end
+
+  def test_has_official_entry_true_when_index_returns_title
+    index = Struct.new(:_) {
+      def lookup(_)        = 'Some Game'
+      def lookup_by_md5(*) = nil
+    }.new(nil)
+    info = Gemba::RomInfo.from_rom(ROM, game_index: index)
+    assert info.has_official_entry
+  end
+
+  def test_has_official_entry_false_when_index_returns_nil
+    info = Gemba::RomInfo.from_rom(ROM, game_index: NULL_INDEX)
+    refute info.has_official_entry
+  end
+
+  def test_has_official_entry_false_when_no_game_code
+    rom  = ROM.merge('game_code' => nil)
+    info = Gemba::RomInfo.from_rom(rom, game_index: NULL_INDEX)
+    refute info.has_official_entry
+  end
+
+  def test_boxart_path_returns_custom_when_file_exists
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      custom    = File.join(dir, "custom.png")
+      File.write(custom, "fake")
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+      overrides.set_custom_boxart('AGB_AXVE-DEADBEEF', custom)
+
+      info = Gemba::RomInfo.from_rom(ROM, overrides: overrides, game_index: NULL_INDEX)
+      assert_equal File.join(dir, 'boxart', 'AGB_AXVE-DEADBEEF', 'custom.png'), info.boxart_path
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+
+  def test_boxart_path_falls_back_to_cache_when_no_custom
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      cache_dir = File.join(dir, "boxart")
+      fetcher   = Gemba::BoxartFetcher.new(app: nil, cache_dir: cache_dir,
+                                            backend: Gemba::BoxartFetcher::NullBackend.new)
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+
+      cached = fetcher.cached_path('AGB-AXVE')
+      FileUtils.mkdir_p(File.dirname(cached))
+      File.write(cached, "fake")
+
+      info = Gemba::RomInfo.from_rom(ROM, fetcher: fetcher, overrides: overrides, game_index: NULL_INDEX)
+      assert_equal cached, info.boxart_path
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+
+  def test_boxart_path_nil_when_neither_present
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      fetcher   = Gemba::BoxartFetcher.new(app: nil, cache_dir: File.join(dir, "boxart"),
+                                            backend: Gemba::BoxartFetcher::NullBackend.new)
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+
+      info = Gemba::RomInfo.from_rom(ROM, fetcher: fetcher, overrides: overrides, game_index: NULL_INDEX)
+      assert_nil info.boxart_path
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+
+  def test_custom_beats_cache_in_boxart_path
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      cache_dir = File.join(dir, "boxart")
+      fetcher   = Gemba::BoxartFetcher.new(app: nil, cache_dir: cache_dir,
+                                            backend: Gemba::BoxartFetcher::NullBackend.new)
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+
+      cached = fetcher.cached_path('AGB-AXVE')
+      FileUtils.mkdir_p(File.dirname(cached))
+      File.write(cached, "cached")
+
+      src = File.join(dir, "my_cover.png")
+      File.write(src, "custom")
+      overrides.set_custom_boxart('AGB_AXVE-DEADBEEF', src)
+
+      info = Gemba::RomInfo.from_rom(ROM, fetcher: fetcher, overrides: overrides, game_index: NULL_INDEX)
+      assert_match %r{custom\.png$}, info.boxart_path, "Custom should beat cached"
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+end

data/test/test_rom_overrides.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+require "gemba/headless"
+
+class TestRomOverrides < Minitest::Test
+  def setup
+    @tmpdir  = Dir.mktmpdir("rom_overrides_test")
+    @json    = File.join(@tmpdir, "rom_overrides.json")
+    @boxart  = File.join(@tmpdir, "boxart")
+    # Point Config.boxart_dir at our tmpdir so copies land there
+    @orig_env = ENV['GEMBA_CONFIG_DIR']
+    ENV['GEMBA_CONFIG_DIR'] = @tmpdir
+  end
+
+  def teardown
+    ENV['GEMBA_CONFIG_DIR'] = @orig_env
+    FileUtils.rm_rf(@tmpdir)
+  end
+
+  def test_custom_boxart_returns_nil_when_nothing_set
+    overrides = Gemba::RomOverrides.new(@json)
+    assert_nil overrides.custom_boxart("AGB_AXVE-DEADBEEF")
+  end
+
+  def test_set_custom_boxart_copies_file_and_returns_dest
+    src = File.join(@tmpdir, "cover.png")
+    File.write(src, "fake png")
+
+    overrides = Gemba::RomOverrides.new(@json)
+    dest = overrides.set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    assert File.exist?(dest), "Copied file should exist at dest"
+    assert_equal "fake png", File.read(dest)
+    assert_match %r{/AGB_AXVE-DEADBEEF/custom\.png$}, dest
+  end
+
+  def test_set_custom_boxart_persists_across_reload
+    src = File.join(@tmpdir, "cover.png")
+    File.write(src, "fake png")
+
+    Gemba::RomOverrides.new(@json).set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    reloaded = Gemba::RomOverrides.new(@json)
+    stored   = reloaded.custom_boxart("AGB_AXVE-DEADBEEF")
+    refute_nil stored
+    assert File.exist?(stored)
+  end
+
+  def test_set_custom_boxart_preserves_extension
+    src = File.join(@tmpdir, "cover.jpg")
+    File.write(src, "fake jpg")
+
+    overrides = Gemba::RomOverrides.new(@json)
+    dest = overrides.set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    assert dest.end_with?(".jpg"), "Extension should be preserved"
+  end
+
+  def test_multiple_rom_ids_stored_independently
+    src1 = File.join(@tmpdir, "a.png"); File.write(src1, "a")
+    src2 = File.join(@tmpdir, "b.png"); File.write(src2, "b")
+
+    overrides = Gemba::RomOverrides.new(@json)
+    overrides.set_custom_boxart("AGB_AXVE-AAAAAAAA", src1)
+    overrides.set_custom_boxart("AGB_BPEE-BBBBBBBB", src2)
+
+    assert_match %r{AAAAAAAA}, overrides.custom_boxart("AGB_AXVE-AAAAAAAA")
+    assert_match %r{BBBBBBBB}, overrides.custom_boxart("AGB_BPEE-BBBBBBBB")
+    assert_nil overrides.custom_boxart("AGB_ZZZZ-ZZZZZZZZ")
+  end
+
+  def test_json_file_is_valid_json
+    src = File.join(@tmpdir, "cover.png")
+    File.write(src, "fake")
+
+    Gemba::RomOverrides.new(@json).set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    parsed = JSON.parse(File.read(@json))
+    assert_instance_of Hash, parsed
+    assert parsed.key?("AGB_AXVE-DEADBEEF")
+  end
+end

data/test/test_rom_patcher.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "zlib"
+require "stringio"
+
+# Bootstrap Zeitwerk autoloading without Tk/SDL2.
+require_relative "../lib/gemba/headless"
+
+class TestRomPatcher < Minitest::Test
+
+  # ---------------------------------------------------------------------------
+  # Fixture helpers — build valid binary patch data in-memory
+  # ---------------------------------------------------------------------------
+
+  # Build a minimal IPS patch that applies the given records.
+  # records: [{offset:, data:}] or [{offset:, rle_count:, rle_val:}]
+  def build_ips(records)
+    io = StringIO.new.tap { |s| s.binmode }
+    io.write("PATCH")
+    records.each do |rec|
+      off = rec[:offset]
+      io.write([off >> 16, (off >> 8) & 0xFF, off & 0xFF].pack("CCC"))
+      if rec[:rle_count]
+        io.write([0, rec[:rle_count]].pack("nn"))
+        io.write([rec[:rle_val]].pack("C"))
+      else
+        io.write([rec[:data].bytesize].pack("n"))
+        io.write(rec[:data].b)
+      end
+    end
+    io.write("EOF")
+    io.string.b
+  end
+
+  # Encode a BPS varint (byuu's additive-shift encoding).
+  def bps_varint(n)
+    out = "".b
+    loop do
+      x = n & 0x7f
+      n >>= 7
+      if n == 0
+        out << (0x80 | x).chr
+        break
+      end
+      out << x.chr
+      n -= 1
+    end
+    out
+  end
+
+  # Build a BPS patch using only TargetRead records (writes literal target data).
+  # Simplest valid BPS: ignores source entirely, just emits target bytes.
+  def build_bps(source, target)
+    source = source.b
+    target = target.b
+    body = StringIO.new.tap { |s| s.binmode }
+    body.write("BPS1")
+    body.write(bps_varint(source.bytesize))
+    body.write(bps_varint(target.bytesize))
+    body.write(bps_varint(0))           # metadata_size = 0
+    # One TargetRead record covering the entire target
+    word = ((target.bytesize - 1) << 2) | 1
+    body.write(bps_varint(word))
+    body.write(target)
+    payload = body.string.b
+    src_crc   = Zlib.crc32(source)
+    tgt_crc   = Zlib.crc32(target)
+    patch_crc = Zlib.crc32(payload)
+    payload + [src_crc, tgt_crc, patch_crc].pack("VVV")
+  end
+
+  # Encode a UPS varint (simple bitshift encoding).
+  def ups_varint(n)
+    out = "".b
+    loop do
+      x = n & 0x7f
+      n >>= 7
+      if n == 0
+        out << (0x80 | x).chr
+        break
+      end
+      out << x.chr
+    end
+    out
+  end
+
+  # Build a UPS patch from source → target.
+  def build_ups(source, target)
+    source = source.b
+    target = target.b
+    max_size = [source.bytesize, target.bytesize].max
+
+    # Collect diff hunks: each is {start:, xor_bytes:}
+    hunks = []
+    i = 0
+    while i < max_size
+      s = source.getbyte(i) || 0
+      t = target.getbyte(i) || 0
+      if s != t
+        hunk_start = i
+        xor_bytes  = "".b
+        while i < max_size
+          s = source.getbyte(i) || 0
+          t = target.getbyte(i) || 0
+          break if s == t
+          xor_bytes << (s ^ t).chr
+          i += 1
+        end
+        hunks << { start: hunk_start, xor_bytes: xor_bytes }
+      else
+        i += 1
+      end
+    end
+
+    # Build body
+    body = StringIO.new.tap { |s| s.binmode }
+    body.write("UPS1")
+    body.write(ups_varint(source.bytesize))
+    body.write(ups_varint(target.bytesize))
+
+    pos = 0
+    hunks.each do |h|
+      skip = h[:start] - pos
+      body.write(ups_varint(skip))
+      body.write(h[:xor_bytes])
+      body.write("\x00")
+      pos = h[:start] + h[:xor_bytes].bytesize + 1
+    end
+
+    payload = body.string.b
+    src_crc   = Zlib.crc32(source)
+    tgt_crc   = Zlib.crc32(target)
+    patch_crc = Zlib.crc32(payload)
+    payload + [src_crc, tgt_crc, patch_crc].pack("VVV")
+  end
+
+  # A small fake ROM — 64 zero bytes, like a blank cartridge header area.
+  def blank_rom(size = 64)
+    "\x00".b * size
+  end
+
+  # ---------------------------------------------------------------------------
+  # RomPatcher (dispatcher)
+  # ---------------------------------------------------------------------------
+
+  def test_detect_format_ips
+    patch = "PATCH" + "EOF"
+    assert_equal :ips, Gemba::RomPatcher.detect_format(patch)
+  end
+
+  def test_detect_format_bps
+    patch = "BPS1\x00"
+    assert_equal :bps, Gemba::RomPatcher.detect_format(patch)
+  end
+
+  def test_detect_format_ups
+    patch = "UPS1\x00"
+    assert_equal :ups, Gemba::RomPatcher.detect_format(patch)
+  end
+
+  def test_detect_format_unknown
+    assert_nil Gemba::RomPatcher.detect_format("JUNK")
+  end
+
+  def test_safe_out_path_no_collision
+    path = "/tmp/nonexistent_gemba_test_#{Process.pid}.gba"
+    assert_equal path, Gemba::RomPatcher.safe_out_path(path)
+  end
+
+  def test_safe_out_path_collision
+    Dir.mktmpdir do |dir|
+      base = File.join(dir, "game.gba")
+      File.write(base, "x")
+      result = Gemba::RomPatcher.safe_out_path(base)
+      assert_equal File.join(dir, "game-(2).gba"), result
+    end
+  end
+
+  def test_safe_out_path_multiple_collisions
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "game.gba"),     "x")
+      File.write(File.join(dir, "game-(2).gba"), "x")
+      result = Gemba::RomPatcher.safe_out_path(File.join(dir, "game.gba"))
+      assert_equal File.join(dir, "game-(3).gba"), result
+    end
+  end
+
+  def test_patch_dispatches_to_ips
+    Dir.mktmpdir do |dir|
+      rom_path   = File.join(dir, "rom.gba")
+      patch_path = File.join(dir, "fix.ips")
+      out_path   = File.join(dir, "rom-patched.gba")
+
+      source = blank_rom
+      File.binwrite(rom_path, source)
+      File.binwrite(patch_path, build_ips([{ offset: 0, data: "\xFF\xFE\xFD\xFC" }]))
+
+      Gemba::RomPatcher.patch(rom_path: rom_path, patch_path: patch_path, out_path: out_path)
+      result = File.binread(out_path)
+      assert_equal "\xFF".b, result[0, 1]
+      assert_equal "\xFE".b, result[1, 1]
+    end
+  end
+
+  def test_patch_raises_on_unknown_format
+    Dir.mktmpdir do |dir|
+      File.binwrite(File.join(dir, "rom.gba"),   "X" * 16)
+      File.binwrite(File.join(dir, "bad.xyz"),   "JUNK")
+      assert_raises(RuntimeError) do
+        Gemba::RomPatcher.patch(
+          rom_path:   File.join(dir, "rom.gba"),
+          patch_path: File.join(dir, "bad.xyz"),
+          out_path:   File.join(dir, "out.gba")
+        )
+      end
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # IPS
+  # ---------------------------------------------------------------------------
+
+  def test_ips_overwrites_bytes_at_offset
+    source = blank_rom
+    patch  = build_ips([{ offset: 4, data: "\xFF\xFE\xFD" }])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal "\x00".b * 4, result[0, 4], "bytes before offset unchanged"
+    assert_equal "\xFF\xFE\xFD".b, result[4, 3], "patch bytes applied"
+    assert_equal "\x00".b, result[7, 1], "bytes after patch unchanged"
+  end
+
+  def test_ips_rle_record_fills_region
+    source = blank_rom
+    patch  = build_ips([{ offset: 8, rle_count: 4, rle_val: 0xAB }])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal "\xAB".b * 4, result[8, 4]
+    assert_equal "\x00".b, result[7, 1], "byte before RLE unchanged"
+    assert_equal "\x00".b, result[12, 1], "byte after RLE unchanged"
+  end
+
+  def test_ips_multiple_records
+    source = blank_rom
+    patch  = build_ips([
+      { offset: 0,  data: "\x01\x02" },
+      { offset: 10, data: "\x03\x04" },
+    ])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal "\x01\x02".b, result[0, 2]
+    assert_equal "\x03\x04".b, result[10, 2]
+  end
+
+  def test_ips_extends_rom_if_patch_exceeds_size
+    source = "\x00".b * 4
+    patch  = build_ips([{ offset: 8, data: "\xFF\xFF" }])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert result.bytesize >= 10, "ROM extended to fit patch"
+    assert_equal "\xFF\xFF".b, result[8, 2]
+  end
+
+  def test_ips_empty_patch_returns_rom_unchanged
+    source = "HELLO".b
+    patch  = build_ips([])
+    result = Gemba::RomPatcher::IPS.apply(source, patch)
+    assert_equal source, result
+  end
+
+  # ---------------------------------------------------------------------------
+  # BPS
+  # ---------------------------------------------------------------------------
+
+  def test_bps_target_read_produces_correct_output
+    source = blank_rom(8)
+    target = "\x11\x22\x33\x44\x55\x66\x77\x88".b
+    patch  = build_bps(source, target)
+    result = Gemba::RomPatcher::BPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  def test_bps_crc_mismatch_raises
+    source = blank_rom(8)
+    target = "\xDE\xAD\xBE\xEF\x00\x00\x00\x00".b
+    patch  = build_bps(source, target)
+    # Corrupt the source CRC (bytes -12..-9)
+    bad_patch = patch.dup.b
+    bad_patch[-12] = "\xFF".b
+    err = assert_raises(RuntimeError) { Gemba::RomPatcher::BPS.apply(source, bad_patch) }
+    assert_match(/CRC32/, err.message)
+  end
+
+  def test_bps_identical_source_and_target
+    source = "GEMBA".b
+    target = "GEMBA".b
+    patch  = build_bps(source, target)
+    result = Gemba::RomPatcher::BPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  # ---------------------------------------------------------------------------
+  # UPS
+  # ---------------------------------------------------------------------------
+
+  def test_ups_xors_differing_bytes
+    source = "\x00\x00\x00\x00".b
+    target = "\xFF\x00\xFF\x00".b
+    patch  = build_ups(source, target)
+    result = Gemba::RomPatcher::UPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  def test_ups_multiple_hunks
+    source = "\x00" * 16
+    target = source.dup.b
+    target.setbyte(0,  0xAA)
+    target.setbyte(8,  0xBB)
+    target.setbyte(15, 0xCC)
+    patch  = build_ups(source.b, target)
+    result = Gemba::RomPatcher::UPS.apply(source.b, patch)
+    assert_equal target, result
+  end
+
+  def test_ups_crc_mismatch_raises
+    source = blank_rom(8)
+    target = "\xCA\xFE\xBA\xBE\x00\x00\x00\x00".b
+    patch  = build_ups(source, target)
+    bad_patch = patch.dup.b
+    bad_patch[-12] = "\x00".b
+    bad_patch[-11] = "\x00".b
+    err = assert_raises(RuntimeError) { Gemba::RomPatcher::UPS.apply(source, bad_patch) }
+    assert_match(/CRC32/, err.message)
+  end
+
+  def test_ups_identical_source_and_target
+    source = "GEMBA\x00\x00\x00".b
+    target = source.dup
+    patch  = build_ups(source, target)
+    result = Gemba::RomPatcher::UPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  def test_ups_pads_target_when_source_is_shorter
+    # target_size > source_size — result zero-pads to target_size
+    source = "\x01\x02".b
+    target = "\x01\x03\x00\x00".b  # byte 1 differs; bytes 2-3 are 0 (matching padding)
+    patch  = build_ups(source, target)
+    result = Gemba::RomPatcher::UPS.apply(source, patch)
+    assert_equal target, result
+  end
+
+  # ---------------------------------------------------------------------------
+  # ZIP ROM input
+  # ---------------------------------------------------------------------------
+
+  def test_patch_with_zip_rom_produces_gba_output
+    require 'zip'
+    dir = Dir.mktmpdir
+    begin
+      # Build a tiny ROM and wrap it in a zip
+      rom_data   = blank_rom
+      zip_path   = File.join(dir, "game.zip")
+      patch_path = File.join(dir, "fix.ips")
+      out_path   = File.join(dir, "game-patched.gba")
+
+      Zip::OutputStream.open(zip_path) do |zos|
+        zos.put_next_entry("game.gba")
+        zos.write(rom_data)
+      end
+
+      File.binwrite(patch_path, build_ips([{ offset: 0, data: "\xFF\xFE" }]))
+
+      resolved = Gemba::RomResolver.resolve(zip_path)
+      Gemba::RomPatcher.patch(rom_path: resolved, patch_path: patch_path, out_path: out_path)
+
+      assert File.exist?(out_path), "expected output at #{out_path}"
+      assert_equal ".gba", File.extname(out_path)
+      assert_equal "\xFF".b, File.binread(out_path, 1)
+    ensure
+      # Windows may still hold the zip file handle until GC — ignore EACCES on cleanup
+      FileUtils.remove_entry(dir) rescue nil
+    end
+  end
+end