gemba 0.1.0

data/lib/gemba/method_coverage_service.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require "json"
+require "prism"
+
+module Gemba
+  # @api private
+  # Transforms SimpleCov line coverage data into per-method coverage.
+  #
+  # Merges coverage data from all test suite result files, uses Prism to
+  # parse Ruby source files and find method definitions, then maps
+  # SimpleCov line coverage to calculate per-method percentages.
+  #
+  # @example
+  #   service = MethodCoverageService.new(
+  #     coverage_dir: "coverage",
+  #     source_dirs: ["lib"]
+  #   )
+  #   service.call
+  #   # => writes coverage/method_coverage.json
+  #
+  class MethodCoverageService
+    attr_reader :coverage_dir, :source_dirs, :output_path
+
+    def initialize(coverage_dir:, source_dirs: ["lib"], output_path: nil)
+      @coverage_dir = coverage_dir
+      @source_dirs = source_dirs
+      @output_path = output_path || File.join(coverage_dir, "method_coverage.json")
+    end
+
+    def call
+      coverage_files = Dir.glob(File.join(coverage_dir, "results", "*", "coverage.json"))
+      resultset_files = Dir.glob(File.join(coverage_dir, "results", "*", ".resultset.json"))
+      if coverage_files.empty? && resultset_files.empty?
+        warn "No coverage files found in #{coverage_dir}/results/"
+        return nil
+      end
+
+      coverage_data = load_and_merge_coverage(coverage_files)
+      result = {}
+
+      # Collect all methods from all files
+      all_methods = []
+      source_files.each do |file|
+        all_methods.concat(extract_methods(file))
+      end
+
+      # Group by class path and calculate coverage
+      all_methods.group_by { |m| m[:class_path] }.each do |class_path, methods|
+        class_result = { "class_methods" => {}, "instance_methods" => {} }
+        total_covered = 0
+        total_relevant = 0
+
+        methods.each do |method|
+          file_coverage = coverage_data[method[:file]]
+          next unless file_coverage
+
+          cov = calculate_coverage(file_coverage, method[:start_line], method[:end_line])
+          next unless cov
+
+          # Store [percent, lines_string] - compact format
+          method_data = [cov[:percent], cov[:lines]]
+          if method[:scope] == :class
+            class_result["class_methods"][method[:name]] = method_data
+          else
+            class_result["instance_methods"][method[:name]] = method_data
+          end
+
+          total_covered += cov[:covered]
+          total_relevant += cov[:relevant]
+        end
+
+        next if class_result["class_methods"].empty? && class_result["instance_methods"].empty?
+
+        if total_relevant > 0
+          class_result["total"] = (total_covered.to_f / total_relevant * 100).round(1)
+        end
+
+        result[class_path] = class_result
+      end
+
+      File.write(output_path, JSON.pretty_generate(result))
+      puts "Generated method coverage: #{output_path} (#{result.size} classes/modules)"
+      result
+    end
+
+    private
+
+    def load_and_merge_coverage(coverage_files)
+      merged = {}
+
+      # Read from coverage.json files
+      coverage_files.each do |file|
+        data = JSON.parse(File.read(file))
+        merge_coverage_data(merged, data["coverage"])
+      end
+
+      # Also read from .resultset.json files (worker/subprocess results)
+      resultset_files = Dir.glob(File.join(coverage_dir, "results", "*", ".resultset.json"))
+      resultset_files.each do |file|
+        data = JSON.parse(File.read(file))
+        # Resultsets are nested: { "suite_name" => { "coverage" => { ... } } }
+        data.each do |_suite_name, suite_data|
+          next unless suite_data.is_a?(Hash) && suite_data["coverage"]
+          merge_coverage_data(merged, suite_data["coverage"])
+        end
+      end
+
+      merged
+    end
+
+    def merge_coverage_data(merged, coverage_hash)
+      coverage_hash.each do |path, info|
+        # Normalize Docker /app/... paths to local paths
+        local_path = path.sub(%r{^/app/}, "")
+        lines = info["lines"]
+        if merged[local_path]
+          merged[local_path] = merge_line_coverage(merged[local_path], lines)
+        else
+          merged[local_path] = lines
+        end
+      end
+    end
+
+    def merge_line_coverage(lines_a, lines_b)
+      max_len = [lines_a.size, lines_b.size].max
+      (0...max_len).map do |i|
+        a = lines_a[i]
+        b = lines_b[i]
+        # nil means not relevant (comments, blank lines), "ignored" also not relevant
+        # If EITHER run says nil, treat as not relevant - a comment can't become executable
+        # This handles cases where different test suites have slightly different coverage metadata
+        if a.nil? || a == "ignored" || b.nil? || b == "ignored"
+          # Both nil -> nil, one nil -> nil (trust the nil, it means non-executable)
+          # Unless both are numeric, in which case take max
+          if (a.nil? || a == "ignored") && (b.nil? || b == "ignored")
+            nil
+          elsif a.nil? || a == "ignored"
+            # a is nil, b is numeric - but nil means not relevant, so prefer nil
+            # unless b > 0 (was actually executed, so must be real code)
+            b.to_i > 0 ? b : nil
+          else
+            # b is nil, a is numeric
+            a.to_i > 0 ? a : nil
+          end
+        else
+          [a.to_i, b.to_i].max
+        end
+      end
+    end
+
+    def source_files
+      source_dirs.flat_map { |dir| Dir.glob("#{dir}/**/*.rb") }
+    end
+
+    def extract_methods(file)
+      source = File.read(file)
+      result = Prism.parse(source)
+      methods = []
+
+      visitor = MethodVisitor.new(methods, file)
+      result.value.accept(visitor)
+
+      methods
+    rescue => e
+      warn "Failed to parse #{file}: #{e.message}"
+      []
+    end
+
+    def calculate_coverage(file_lines, start_line, end_line)
+      relevant = 0
+      covered = 0
+      lines_str = +""  # unfrozen string
+
+      # Skip first line (def) and last line (end) - only count method body
+      body_start = start_line + 1
+      body_end = end_line - 1
+
+      return nil if body_start > body_end  # empty method body
+
+      (body_start..body_end).each do |line_num|
+        next if line_num < 1 || line_num > file_lines.size
+        line_cov = file_lines[line_num - 1]  # array is 0-indexed
+        if line_cov.nil? || line_cov == "ignored"
+          lines_str << "-"  # not relevant
+        elsif line_cov.to_i > 0
+          lines_str << "1"  # covered
+          relevant += 1
+          covered += 1
+        else
+          lines_str << "0"  # not covered
+          relevant += 1
+        end
+      end
+
+      return nil if relevant == 0
+      { covered: covered, relevant: relevant, percent: (covered.to_f / relevant * 100).round(1), lines: lines_str }
+    end
+
+    # Prism AST visitor to extract method definitions with class context
+    class MethodVisitor < Prism::Visitor
+      def initialize(methods, file)
+        @methods = methods
+        @file = file
+        @namespace_stack = []  # track current class/module nesting
+        @singleton_depth = 0   # track if we're inside class << self
+      end
+
+      def visit_class_node(node)
+        name = constant_path_to_string(node.constant_path)
+        @namespace_stack.push(name)
+        super
+        @namespace_stack.pop
+      end
+
+      def visit_module_node(node)
+        name = constant_path_to_string(node.constant_path)
+        @namespace_stack.push(name)
+        super
+        @namespace_stack.pop
+      end
+
+      def visit_singleton_class_node(node)
+        @singleton_depth += 1
+        super
+        @singleton_depth -= 1
+      end
+
+      def visit_def_node(node)
+        return super if @namespace_stack.empty?  # skip top-level methods
+
+        scope = if node.receiver || @singleton_depth > 0
+          :class
+        else
+          :instance
+        end
+
+        @methods << {
+          name: node.name.to_s,
+          scope: scope,
+          start_line: node.location.start_line,
+          end_line: node.location.end_line,
+          class_path: @namespace_stack.join("::"),
+          file: @file
+        }
+
+        super
+      end
+
+      private
+
+      def constant_path_to_string(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent ? constant_path_to_string(node.parent) + "::" : ""
+          parent + node.name.to_s
+        else
+          node.to_s
+        end
+      end
+    end
+  end
+end

data/lib/gemba/overlay_renderer.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Gemba
+  # Renders inverse-blend HUD overlays (FPS counter, fast-forward indicator)
+  # on top of the game viewport.
+  #
+  # White source pixels invert the destination, so the text is always
+  # readable regardless of the game's background color. Transparent
+  # regions pass through unchanged.
+  #
+  # @example
+  #   hud = OverlayRenderer.new(font: font, blend_mode: inverse_blend)
+  #   hud.set_fps("59.7 FPS")
+  #   hud.set_ff_label(">> 2x")
+  #   # inside render loop:
+  #   hud.draw(r, dest_rect)
+  class OverlayRenderer
+    # @param font [Teek::SDL2::Font] used to render overlay text
+    # @param blend_mode [Integer] SDL blend mode (typically inverse blend)
+    def initialize(font:, blend_mode:)
+      @font = font
+      @blend_mode = blend_mode
+      @crop_h = compute_crop_h(font)
+      @fps_tex = nil
+      @ff_tex = nil
+    end
+
+    # Update the FPS counter text. Pass nil to hide.
+    # @param text [String, nil]
+    def set_fps(text)
+      @fps_tex&.destroy
+      @fps_tex = text ? build_tex(text) : nil
+    end
+
+    # Update the fast-forward indicator label. Pass nil to hide.
+    # @param text [String, nil]
+    def set_ff_label(text)
+      @ff_tex&.destroy
+      @ff_tex = text ? build_tex(text) : nil
+    end
+
+    # Whether the FPS overlay is currently showing.
+    # @return [Boolean]
+    def fps_visible?
+      !!@fps_tex
+    end
+
+    # Whether the fast-forward label is currently showing.
+    # @return [Boolean]
+    def ff_visible?
+      !!@ff_tex
+    end
+
+    # Draw all active overlays.
+    #
+    # FPS is positioned top-right; FF label is positioned top-left.
+    # Both are inset from the game area defined by +dest+.
+    #
+    # @param r [Teek::SDL2::Renderer]
+    # @param dest [Array(Integer,Integer,Integer,Integer), nil] game area rect
+    # @param show_fps [Boolean] whether to draw the FPS counter
+    # @param show_ff [Boolean] whether to draw the FF indicator
+    def draw(r, dest, show_fps: true, show_ff: false)
+      if show_ff && @ff_tex
+        ox = dest ? dest[0] : 0
+        oy = dest ? dest[1] : 0
+        draw_tex(r, @ff_tex, ox + 4, oy + 4)
+      end
+
+      if show_fps && @fps_tex
+        fx = (dest ? dest[0] + dest[2] : r.output_size[0]) - @fps_tex.width - 6
+        fy = (dest ? dest[1] : 0) + 4
+        draw_tex(r, @fps_tex, fx, fy)
+      end
+    end
+
+    # Free all textures.
+    def destroy
+      @fps_tex&.destroy
+      @fps_tex = nil
+      @ff_tex&.destroy
+      @ff_tex = nil
+    end
+
+    private
+
+    def build_tex(text)
+      return nil unless @font
+      tex = @font.render_text(text, 255, 255, 255)
+      tex.blend_mode = @blend_mode
+      tex
+    end
+
+    # Crop to ascent + partial descender to avoid alpha artifacts
+    # visible under inverse blending.
+    def draw_tex(r, tex, x, y)
+      tw = tex.width
+      th = @crop_h || tex.height
+      r.copy(tex, [0, 0, tw, th], [x, y, tw, th])
+    end
+
+    def compute_crop_h(font)
+      return nil unless font
+      ascent = font.ascent
+      full_h = font.measure('p')[1]
+      [ascent + (full_h - ascent) / 2, full_h - 1].min
+    end
+  end
+end