rspec_telemetry 0.3.0

data/lib/rspec_telemetry/trace/viewer/screen/ranked_screen.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../document"
+require_relative "../theme"
+require_relative "../report_view"
+require_relative "../report_pane"
+require_relative "../detail_lines"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      module Screen
+        class RankedScreen
+          def initialize(document, list, view)
+            @document = document
+            @list = list
+            @view = view
+            refresh
+          end
+
+          def title = ReportView.title(@view)
+          def time_bar? = false
+          def time_bar_current = nil
+          def count = @rows.size
+          def source? = @view == :examples && @rows.any?(&:source)
+
+          def activate = refresh
+
+          def refresh
+            @rows = ReportView.rows(@document, @view)
+            @list.count = @rows.size
+          end
+
+          def draw_list(canvas, rect, focused:)
+            ReportPane.new(@rows, list: @list, focus: focused).draw(canvas, rect)
+          end
+
+          def detail_lines(width)
+            row = @rows[@list.cursor]
+            return [] unless row
+
+            if row.payload.is_a?(Document::Action)
+              action = row.payload
+              DetailLines.for(
+                action,
+                children: @document.events_for(action.seq),
+                duration: action.duration_ms,
+                width: width
+              )
+            else
+              ReportView.detail(row.payload).flat_map do |line|
+                TuiTui::DisplayText.new(line).wrap(width, indent: "  ").map(&:to_s)
+              end
+            end
+          end
+
+          def current_source
+            @view == :examples ? @rows[@list.cursor]&.source : nil
+          end
+
+          def handle_key_event(_event, _app) = nil
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/screen/timeline_screen.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "../document"
+require_relative "../theme"
+require_relative "../label"
+require_relative "../timeline_pane"
+require_relative "../detail_lines"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      module Screen
+        # Timeline-only state: filtering, folding, failure jumps, and live refresh.
+        class TimelineScreen
+          def initialize(document, list)
+            @document = document
+            @list = list
+            @filter = nil
+            @collapsed = Set.new
+            rebuild
+            compute_durations
+          end
+
+          def title = nil
+          def time_bar? = true
+          def source? = @document.actions.any?(&:source)
+          def count = @visible.size
+
+          def activate
+            @collapsed.clear
+            rebuild
+            compute_durations
+          end
+
+          def refresh
+            rebuild
+            compute_durations
+          end
+
+          def draw_list(canvas, rect, focused:)
+            TimelinePane
+              .new(
+                @visible,
+                list: @list,
+                focus: focused,
+                collapsed: @collapsed,
+                childful: @childful,
+                durations: @durations
+              )
+              .draw(canvas, rect)
+          end
+
+          def detail_lines(width)
+            entry = current_entry
+            children = entry.is_a?(Document::Action) ? @document.events_for(entry.seq) : []
+            duration = entry.is_a?(Document::Action) ? @durations[entry.seq] : nil
+            DetailLines.for(entry, children: children, duration: duration, width: width)
+          end
+
+          def current_source
+            entry = current_entry
+            return entry.source if entry.is_a?(Document::Action)
+
+            action = entry.is_a?(Document::Event) ? @document.action(entry.action) : nil
+            action&.source
+          end
+
+          def time_bar_current
+            entry = current_entry
+            return nil if entry.nil?
+
+            entry.is_a?(Document::Action) ? entry.wall_ms : entry.fields["wall_ms"]
+          end
+
+          def handle_key_event(event, app)
+            case event.key
+            when "/"
+              open_filter(app)
+            when "a"
+              open_example_jump(app)
+            when "n"
+              jump_error(app, 1)
+            when "N"
+              jump_error(app, -1)
+            when "\r"
+              toggle_fold(app)
+            when "z"
+              toggle_all_folds(app)
+            end
+          end
+
+          private
+
+          def current_entry = @visible[@list.cursor]
+
+          def rebuild
+            base = filtered_entries
+            @childful = base.filter_map { |entry| entry.action if entry.is_a?(Document::Event) }.to_set
+            @visible = base.reject { |entry| entry.is_a?(Document::Event) && @collapsed.include?(entry.action) }
+            @list.count = @visible.size
+          end
+
+          def filtered_entries
+            return @document.entries unless @filter
+
+            needle = @filter.downcase
+            @document.entries.select { |entry| Label.plain(entry).downcase.include?(needle) }
+          end
+
+          def compute_durations
+            actions = @document.entries.grep(Document::Action)
+            @durations = {}
+            actions.each_with_index do |action, index|
+              # Running examples use the gap to the next example or stream end.
+              @durations[action.seq] = if action.duration_ms
+                action.duration_ms
+              else
+                finish = actions[index + 1]&.wall_ms || @document.end_wall_ms
+                finish && action.wall_ms ? (finish - action.wall_ms) : nil
+              end
+            end
+          end
+
+          def open_filter(app)
+            app.open_modal(TuiTui::Prompt.new("Filter:", value: @filter.to_s, theme: Theme.base)) do |result|
+              apply_filter(app, result[1]) if result.is_a?(Array)
+            end
+          end
+
+          def apply_filter(app, text)
+            @filter = text.empty? ? nil : text
+            rebuild
+            app.go_to(0)
+          end
+
+          def open_example_jump(app)
+            rows = @visible.each_index.select { |i| @visible[i].is_a?(Document::Action) }
+            return if rows.empty?
+
+            app
+              .open_modal(
+                TuiTui::Select.new("Jump to example", rows.map { |i| Label.plain(@visible[i]) }, theme: Theme.base)
+              ) do |result|
+                app.go_to(rows[result]) if result.is_a?(Integer)
+              end
+          end
+
+          def jump_error(app, direction)
+            index = @list.cursor + direction
+            while index.between?(0, @list.last)
+              entry = @visible[index]
+              return app.go_to(index) if entry.is_a?(Document::Action) && entry.failed?
+
+              index += direction
+            end
+          end
+
+          def toggle_fold(app)
+            entry = current_entry
+            seq = entry.is_a?(Document::Action) ? entry.seq : entry&.action
+            return unless seq && @childful.include?(seq)
+
+            @collapsed.include?(seq) ? @collapsed.delete(seq) : @collapsed.add(seq)
+            rebuild
+            index = @visible.index { |e| e.is_a?(Document::Action) && e.seq == seq }
+            app.go_to(index) if index
+          end
+
+          def toggle_all_folds(app)
+            @collapsed.empty? ? @collapsed.replace(@childful) : @collapsed.clear
+            rebuild
+            app.go_to(@list.cursor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/source.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class TailSource
+        def initialize(path)
+          @path = path
+          @offset = 0
+          @partial = +""
+        end
+
+        def drain
+          return [] unless File.file?(@path)
+
+          reset_if_shrunk
+          chunk = read_new_bytes
+          return [] if chunk.empty?
+
+          @partial << chunk
+          split_complete_lines
+        end
+
+        private
+
+        def reset_if_shrunk
+          return unless File.size(@path) < @offset
+
+          @offset = 0
+          @partial = +""
+        end
+
+        def read_new_bytes
+          return "" if File.size(@path) <= @offset
+
+          File.open(@path, "rb") do |file|
+            file.seek(@offset)
+            data = file.read || ""
+            @offset = file.pos
+            data
+          end
+        end
+
+        def split_complete_lines
+          pieces = @partial.split("\n", -1)
+          @partial = pieces.pop || +""
+          pieces.map { |line| line.dup.force_encoding("UTF-8") }
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/source_pane.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "theme"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class SourcePane
+        HEADER = TuiTui::Style.new(attrs: [:reverse])
+        CODE = TuiTui::Style.new(attrs: [:dim])
+        MARK = TuiTui::Style.new(fg: :green, attrs: [:bold])
+
+        def initialize(location:, lines:, target:)
+          @location = location
+          @lines = lines
+          @target = target
+        end
+
+        def draw(canvas, rect)
+          canvas.fill(TuiTui::Rect.new(row: rect.row, col: rect.col, rows: 1, cols: rect.cols), HEADER)
+          canvas.text(
+            rect.row,
+            rect.col,
+            TuiTui::DisplayText.new(" source: #{@location || "(none for this step)"}").truncate(rect.cols),
+            HEADER
+          )
+
+          avail = rect.rows - 1
+          return canvas if avail < 1
+          return placeholder(canvas, rect.row + 1, rect.col, rect.cols) if @lines.nil?
+
+          body = TuiTui::Rect.new(row: rect.row + 1, col: rect.col, rows: avail, cols: rect.cols)
+          draw_window(canvas, body)
+          canvas
+        end
+
+        private
+
+        def placeholder(canvas, row, col, cols)
+          text = @location ? "(source not found)" : "(this step has no recorded source)"
+          canvas.text(row, col, TuiTui::DisplayText.new("  #{text}").truncate(cols), CODE)
+          canvas
+        end
+
+        def self.numbered_line(number, text, target:)
+          "#{number == target ? "→" : " "} #{number.to_s.rjust(4)}  #{text}"
+        end
+
+        def draw_window(canvas, body)
+          top = window_top(body.rows)
+          TuiTui::TextView.draw(canvas, body, top: top) do |index|
+            text = @lines[index]
+            next nil if text.nil?
+
+            number = index + 1
+            line = self.class.numbered_line(number, text, target: @target)
+            TuiTui::Line[TuiTui::Span[line, number == @target ? MARK : CODE]]
+          end
+        end
+
+        def window_top(avail)
+          return 0 if @target.nil?
+
+          centered = @target - 1 - (avail / 2)
+          centered.clamp(0, [@lines.size - avail, 0].max)
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/source_resolver.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class SourceResolver
+        ANCESTOR_DEPTH = 5
+
+        def initialize(source_root:, base_dir: nil)
+          @source_root = source_root
+          @base_dir = base_dir
+          @cache = {}
+        end
+
+        def lines_for(file)
+          return @cache[file] if @cache.key?(file)
+
+          @cache[file] = read(file)
+        end
+
+        def roots
+          @roots ||= begin
+            list = [@source_root]
+            dir = @base_dir
+            ANCESTOR_DEPTH.times do
+              break if dir.nil?
+
+              list << dir
+              parent = ::File.dirname(dir)
+              break if parent == dir
+
+              dir = parent
+            end
+
+            list.compact.uniq
+          end
+        end
+
+        private
+
+        def read(file)
+          roots.each do |root|
+            path = ::File.expand_path(file, root)
+            next unless ::File.file?(path)
+
+            return ::File.readlines(path, chomp: true)
+          rescue SystemCallError
+            next
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/source_view.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "tui_tui"
+
+require_relative "source_pane"
+require_relative "source_resolver"
+require_relative "theme"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class SourceView
+        def initialize(source_root:, base_dir:)
+          @resolver = SourceResolver.new(source_root: source_root, base_dir: base_dir)
+        end
+
+        def draw(canvas, rect, location)
+          file, target = source_location(location)
+          SourcePane
+            .new(location: location, lines: file && @resolver.lines_for(file), target: target)
+            .draw(canvas, rect)
+        end
+
+        def pager(location)
+          return nil unless location
+
+          file, target = source_location(location)
+          lines = numbered_source(@resolver.lines_for(file), target, file)
+          TuiTui::Pager.new(
+            "source: #{location}",
+            lines,
+            start: [target - 4, 0].max,
+            close_keys: ["S"],
+            theme: Theme.base
+          )
+        end
+
+        private
+
+        def source_location(location)
+          return [nil, nil] unless location
+
+          file, _, line = location.rpartition(":")
+          [file, line.to_i]
+        end
+
+        def numbered_source(lines, target, file)
+          if lines.nil?
+            return [
+              "(source not found: #{file})",
+              "looked under: #{@resolver.roots.join(", ")}",
+              "pass --source-root DIR to point at the project root"
+            ]
+          end
+
+          lines.each_with_index.map do |text, index|
+            SourcePane.numbered_line(index + 1, text, target: target)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/status_line.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "theme"
+require_relative "format"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class StatusLine
+        HINTS = "1-3=views  Tab=pane  f=follow  q=quit"
+
+        def initialize(
+          document,
+          position:,
+          follow: false,
+          spinner: nil,
+          pending: false,
+          notice: nil,
+          total_ms: nil,
+          mode: nil
+        )
+          @document = document
+          @position = position
+          @follow = follow
+          @spinner = spinner
+          @pending = pending
+          @notice = notice
+          @total_ms = total_ms
+          @mode = mode
+        end
+
+        def draw(canvas, rect)
+          right = "#{@position}  #{@notice || HINTS} "
+          TuiTui::StatusBar.draw(canvas, rect, left: left_text, right: right, style: Theme::BAR)
+        end
+
+        private
+
+        def left_text
+          text = @mode ? " [#{@mode}]  #{@document.status}" : " #{@document.events.size} events  #{@document.status}"
+          total = Format.ms(@total_ms)
+          text += "  #{total}" if total
+          return text unless @follow
+
+          text + "  follow #{@spinner}#{@pending ? " pending" : ""}"
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/text_report.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "theme"
+require_relative "label"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class TextReport
+        def initialize(document, depth: TuiTui::ColorDepth.detect, enabled: true)
+          @document = document
+          @depth = depth
+          @enabled = enabled
+        end
+
+        def render
+          @document.entries.map { |entry| render_entry(entry) }.join("\n")
+        end
+
+        def summary
+          count = @document.events.size
+          paint("#{count} events  #{@document.status}", status_style)
+        end
+
+        private
+
+        def render_entry(entry)
+          prefix = entry.is_a?(Document::Action) ? "" : "  "
+          prefix + Label.segments(entry).map { |segment| paint(segment.text, segment.style) }.join
+        end
+
+        def paint(text, style_key)
+          Theme.style(style_key).paint(text, depth: @depth, enabled: @enabled)
+        end
+
+        def status_style
+          case @document.status
+          when "failed", "error", "timeout"
+            :error
+          when "ok"
+            :ok
+          else
+            :dim
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/theme.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "tui_tui"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      module Theme
+        S = TuiTui::Style
+        BASE = TuiTui::Theme.auto
+
+        STYLES = {
+          plain: BASE.text,
+          action: S.new(attrs: [:bold]),
+          dim: BASE.muted,
+          error: S.new(fg: :red, attrs: [:bold]),
+          ok: S.new(fg: :green)
+        }.freeze
+
+        SELECT = BASE.selection
+        SELECT_BLUR = BASE.selection_dim
+        BAR = BASE.bar
+
+        def self.base = BASE
+
+        def self.style(key) = STYLES.fetch(key)
+      end
+    end
+  end
+end

data/lib/rspec_telemetry/trace/viewer/time_bar.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "theme"
+require_relative "format"
+
+module RSpecTelemetry
+  module Trace
+    module Viewer
+      class TimeBar
+        LABEL = TuiTui::Style.new(attrs: [:bold])
+        FILL = TuiTui::Style.new(fg: :green)
+        TRACK = TuiTui::Style.new(attrs: [:dim])
+
+        def initialize(current_ms:, total_ms:)
+          @current = current_ms
+          @total = total_ms
+        end
+
+        def draw(canvas, rect)
+          canvas.fill(rect, TRACK)
+          return canvas unless @total && @total.positive?
+
+          current = (@current || 0).clamp(0, @total)
+          percent = (current.to_f / @total * 100).round
+          label = " #{Format.ms(current)} / #{Format.ms(@total)}  #{percent}% "
+          canvas.text(rect.row, rect.col, label, LABEL)
+
+          draw_bar(canvas, rect, current, TuiTui::DisplayText.new(label).width)
+          canvas
+        end
+
+        private
+
+        def draw_bar(canvas, rect, current, label_width)
+          width = rect.cols - label_width
+          return if width < 4
+
+          col = rect.col + label_width
+          filled = (current.to_f / @total * width).round
+          canvas.text(rect.row, col, "=" * filled, FILL)
+          canvas.text(rect.row, col + filled, "-" * (width - filled), TRACK)
+        end
+      end
+    end
+  end
+end