Module: Polyrun::Coverage::ExampleDiff

Defined in:
lib/polyrun/coverage/example_diff.rb,
lib/polyrun/coverage/example_diff_snapshot.rb,
lib/polyrun/coverage/example_diff_track_filter.rb

Overview

Per-example line hit deltas from stdlib Coverage.peek_result snapshots.

Defined Under Namespace

Modules: Snapshot Classes: TrackFilter

Class Method Summary collapse

Class Method Details

.apply_track_under(delta, root:, track_under:, ignore_paths: []) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/polyrun/coverage/example_diff.rb', line 73

def apply_track_under(delta, root:, track_under:, ignore_paths: [])
  filtered = filter_lines(delta[:lines] || [], root: root, track_under: track_under, ignore_paths: ignore_paths)
  unique = filtered.size
  churn = filtered.sum { |(_path, _line, hit_delta)| hit_delta }
  max_churn = filtered.map { |(_path, _line, hit_delta)| hit_delta }.max || 0
  {
    unique_lines: unique,
    line_churn: churn,
    max_line_churn: max_churn,
    lines: filtered
  }
end

.coverage_active? ⇒ Boolean

Returns:

  • (Boolean) 


50
51
52
 
# File 'lib/polyrun/coverage/example_diff.rb', line 50

def coverage_active?
  defined?(::Coverage) && ::Coverage.respond_to?(:running?) && ::Coverage.running?
end

.diff(before_blob, after_source, root: nil, track_under: nil, ignore_paths: nil) ⇒ Object

after_source may be a normalized blob or a raw Coverage.peek_result hash.



41
42
43
44
45
46
47
48
 
# File 'lib/polyrun/coverage/example_diff.rb', line 41

def diff(before_blob, after_source, root: nil, track_under: nil, ignore_paths: nil)
  filter = track_filter_for(root: root, track_under: track_under, ignore_paths: ignore_paths)
  if raw_peek_result?(after_source)
    diff_against_peek(before_blob, after_source, filter: filter)
  else
    diff_blobs(before_blob, after_source, filter: filter)
  end
end

.diff_against_peek(before_blob, after_raw, filter: nil) ⇒ Object 



61
62
63
64
65
66
 
# File 'lib/polyrun/coverage/example_diff.rb', line 61

def diff_against_peek(before_blob, after_raw, filter: nil)
  before_blob ||= {}
  after_raw ||= {}
  paths = collect_diff_paths(before_blob, after_raw, filter: filter)
  diff_paths(paths, before_blob, after_raw, raw_after: true)
end

.diff_blobs(before_blob, after_blob, filter: nil) ⇒ Object 



54
55
56
57
58
59
 
# File 'lib/polyrun/coverage/example_diff.rb', line 54

def diff_blobs(before_blob, after_blob, filter: nil)
  before_blob ||= {}
  after_blob ||= {}
  paths = collect_diff_paths(before_blob, after_blob, filter: filter)
  diff_paths(paths, before_blob, after_blob, raw_after: false)
end

.filter_lines(lines, root:, track_under:, ignore_paths: []) ⇒ Object 



68
69
70
71
 
# File 'lib/polyrun/coverage/example_diff.rb', line 68

def filter_lines(lines, root:, track_under:, ignore_paths: [])
  filter = TrackFilter.new(root: root, track_under: track_under, ignore_paths: ignore_paths)
  lines.select { |path, _line, _delta| filter.include_path?(path) }
end

.line_array(entry) ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/polyrun/coverage/example_diff.rb', line 86

def line_array(entry)
  return [] unless entry.is_a?(Hash)
  return [] if entry["sparse"]

  arr = entry["lines"] || entry[:lines]
  arr.is_a?(Array) ? arr : []
end

.peek_blob(root: nil, track_under: nil, ignore_paths: nil) ⇒ Hash{String=>Hash}

Returns path => sparse line snapshot.

Returns:

  • (Hash{String=>Hash}) —

    path => sparse line snapshot



11
12
13
14
15
16
17
18
19
20
 
# File 'lib/polyrun/coverage/example_diff.rb', line 11

def peek_blob(root: nil, track_under: nil, ignore_paths: nil)
  return {} unless coverage_active?

  snapshot_peek(
    ::Coverage.peek_result,
    root: root,
    track_under: track_under,
    ignore_paths: ignore_paths
  )
end

.snapshot_peek(raw, root: nil, track_under: nil, ignore_paths: nil) ⇒ Object

Frozen snapshot for storage between peeks (stdlib mutates line arrays in place).



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/polyrun/coverage/example_diff.rb', line 23

def snapshot_peek(raw, root: nil, track_under: nil, ignore_paths: nil)
  return {} if raw.nil? || raw.empty?

  filter = track_filter_for(root: root, track_under: track_under, ignore_paths: ignore_paths)
  out = {}
  raw.each do |path, coverage_entry|
    next unless coverage_entry.is_a?(Hash)
    next if filter && !filter.include_path?(path.to_s)

    lines = coverage_entry[:lines] || coverage_entry["lines"]
    next unless lines.is_a?(Array)

    out[path.to_s] = Snapshot.sparse_snapshot_lines(lines)
  end
  out
end