condition_coverage 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0b1aba7a743838c35d3b4d139b40efebafd48edef44b82ffc48f7c045eb6861
-  data.tar.gz: '074496c6beaf83b9c6ec438019eb20e7b4f8231230ba94cd5e7a87cc2dc01eb1'
+  metadata.gz: a61c323a92442b231f61a10ea7ee622ee5e3b957f9818819e56aefda2ed75efd
+  data.tar.gz: eba0b9b94f2ba0756f0549d9675a4d3cb4c548df4854114df6e76e7ce09cdbeb
 SHA512:
-  metadata.gz: debb313edef170467b8146405bc25f212b852798c19492b20699a111d255c05015ade7357a90cc9666e9a5642674fa31a0dcea3f930978bd2ef8bad2b37cab04
-  data.tar.gz: e90aa8e71930f57e5e50b5f70155d7166ace8741f300abb7092bafbb3d47bafaaa3ce409cfe7102fc1795dfe7cea5224961a8497e027a617351b371010d83432
+  metadata.gz: f84973aba8aa9323ba03323f5fabe1b99feda591d0973a715e27f792a61971c50fb87b90680db5245451f16a90180dcae7272a8bdc33fd25998429d63860cd45
+  data.tar.gz: b992c871ed4f1bd658d828fec3da583199a4ddf3a44c26f0cb79b142f57f74e294a5f9c50e672780fb4f213986163f9c5b0a64e03903e462aebaf8c7a78e07ae

data/README.md

@@ -3,7 +3,7 @@
 Condition coverage for Ruby, to run alongside SimpleCov's line and branch
 coverage.
 
-Status: 0.0.3 covers `&&`, `||`, `and` and `or`: each leaf operand of a
+Status: 0.0.5 covers `&&`, `||`, `and` and `or`: each leaf operand of a
 condition, however its operators are chained, nested or grouped. Decisions
 hidden inside calls come next (see Roadmap).
 
@@ -75,6 +75,16 @@ A chain of one operator is flat; a change of operator, by precedence or by
 parentheses, nests. Parentheses are not part of the tree, since they decide
 nothing.
 
+An operand whose form allows one outcome only needs only to be evaluated:
+its other outcome is impossible, not a gap. `Foo.new`, literals (`'s'`,
+`1`, `:k`, `[]`, `{}`, `true`), lambdas and constants (`LATEST`,
+`Config::DEFAULT`, since one holding nil or false is rare) can only be
+truthy; `nil` and `false` only falsy:
+
+```ruby
+@clock = options[:clock] || MonotonicClock.new  # operand 1: never evaluated, or no gap
+```
+
 - `:html` writes `index.html` to `coverage_dir`: the covered files with
   their sites, outcomes seen (with a percent) and outcomes missing, each
   column sortable. Each file name opens `files/<path>.html`, the file's
@@ -83,7 +93,10 @@ nothing.
   missing) that opens a tree of the condition: its operators, nested as
   Ruby groups them, and each leaf operand's true and false counts and its
   gap. A condition written over several lines has one button over all of
-  its line numbers.
+  its line numbers. Trees with gaps start open. A header that stays at
+  the top of the page lists every site as a link to its line, covered
+  sites first, then those with gaps, and arrows beside each site with
+  gaps jump to the previous and next one, wrapping round at either end.
 
 ## How it works
 

data/lib/condition_coverage/condition.rb

@@ -2,10 +2,12 @@ module ConditionCoverage
   # One site's condition as the manifest found it: its operator
   # and its operands, each the byte range of a leaf or a nested
   # Condition. A site's commands are the byte ranges of its
-  # leaves that are command calls, eg `ok? id`.
-  Condition = Data.define(:operator, :operands, :commands) do
-    # A condition with no command-call leaves by default.
-    def initialize(operator:, operands:, commands: [])
+  # leaves that are command calls, eg `ok? id`; its fixed are
+  # { byte range => :truthy } for leaves that can have that one
+  # outcome only, eg `Clock.new`.
+  Condition = Data.define(:operator, :operands, :commands, :fixed) do
+    # A condition with no command-call or fixed leaves by default.
+    def initialize(operator:, operands:, commands: [], fixed: {})
       super
     end
 

data/lib/condition_coverage/gaps.rb

@@ -25,9 +25,11 @@ module ConditionCoverage
       end
     end
 
-    # The one outcome this operand is missing, if any.
+    # The one outcome this operand is missing, if any; a fixed
+    # leaf, which can have one outcome only, needs only to run.
     def self.operand_gap(counts)
       return ['never evaluated'] if never_ran?(counts)
+      return [] if counts[:only]
       return ['never true'] if counts[:truthy].zero?
       return ['never false'] if counts[:falsy].zero?
 

data/lib/condition_coverage/html/file.html

@@ -12,8 +12,11 @@
 </head>
 <body>
 <main class="page">
+<header class="head" data-head="">
 <p class="back"><a data-index="" href="{{index}}">Condition coverage</a></p>
 <h1 class="path">{{path}}</h1>
+{{jumps}}
+</header>
 <div class="box">
 {{listing}}
 </div>

data/lib/condition_coverage/html/style.css

@@ -13,6 +13,13 @@
   --bad: #B54708;
   --on-status: #FFFFFF;
   --link: #1F5FBF;
+  /* The tree is inverted from the page, so it never reads as
+     more source lines. */
+  --tree-bg: #1E2638;
+  --tree-fg: #E8ECF4;
+  --tree-muted: #A3AEC2;
+  --tree-rule: #3A4560;
+  --tree-gap: #F5A25D;
   --font-body: "Helvetica Neue", Arial, sans-serif;
   --font-code: Menlo, Consolas, "DejaVu Sans Mono", monospace;
 }
@@ -21,6 +28,8 @@
     --bg: #12151C; --surface: #181C25; --panel: #212633; --fg: #E4E8EF;
     --muted: #9AA4B5; --rule: #323949; --ok: #7FB0FF; --ok-tint: #1A2740;
     --warn: #F0A35E; --bad: #F08A3C; --on-status: #12151C; --link: #7FB0FF;
+    --tree-bg: #E6EAF2; --tree-fg: #1C2230; --tree-muted: #4E5869;
+    --tree-rule: #BCC4D2; --tree-gap: #A8480A;
     color-scheme: dark;
   }
 }
@@ -52,6 +61,39 @@ th button:focus-visible { outline: 3px solid var(--link); outline-offset: 2px; }
    digits stay aligned whether or not they are on a button. */
 .back { margin: 0; font-size: 14px; }
 h1.path { font-family: var(--font-code); font-size: 20px; }
+/* The back link, path and site lists stick together as one
+   header. */
+.head {
+  position: sticky; top: 0; z-index: 5;
+  display: flex; flex-direction: column; gap: 10px;
+  margin: 0 -16px; padding: 12px 16px; background: var(--bg);
+  border-bottom: 1px solid var(--rule);
+}
+.jumps { display: flex; flex-direction: column; gap: 8px; }
+.jump-list { display: flex; gap: 6px; align-items: center; overflow-x: auto; white-space: nowrap; min-width: 0; }
+.jump-label { width: 64px; flex-shrink: 0; font-size: 12px; color: var(--muted); text-transform: uppercase; letter-spacing: 0.06em; }
+a.jump {
+  font: 600 13px/22px var(--font-code); padding: 0 9px; border-radius: 999px;
+  text-decoration: none; border: 1px solid; font-variant-numeric: tabular-nums;
+}
+a.jump[data-status="covered"] { background: var(--ok-tint); color: var(--ok); border-color: var(--ok); }
+a.jump[data-status="gaps"] { background: var(--bad); color: var(--on-status); border-color: var(--bad); }
+a.jump:focus-visible, .nav a:focus-visible { outline: 3px solid var(--link); outline-offset: 2px; }
+/* The source pane's border and background start after the nav
+   column, so the arrows sit outside the pane yet scroll with
+   their line. */
+.box:has(> .code) { position: relative; isolation: isolate; border: 0; background: none; border-radius: 0; }
+.box:has(> .code)::before {
+  content: ""; position: absolute; inset: 0 0 0 48px; z-index: -1;
+  border: 1px solid var(--rule); border-radius: 8px;
+  background: var(--surface); pointer-events: none;
+}
+.nav { display: flex; width: 48px; flex-shrink: 0; }
+.nav a { width: 22px; text-align: center; line-height: 32px; font-size: 18px; color: var(--bad); text-decoration: none; }
+.nav a:hover { color: var(--fg); }
+/* Clears the sticky header when a link jumps to a line. */
+.lineno { scroll-margin-top: 190px; }
+button.lnum:has(.lineno:target) { outline: 3px solid var(--link); outline-offset: 2px; }
 .code { font-family: var(--font-code); font-size: 14px; line-height: 32px; padding: 10px 0; min-width: 720px; }
 .line, .block { display: flex; align-items: flex-start; }
 .srcs { display: flex; flex-direction: column; }
@@ -84,7 +126,7 @@ button.lnum:has(.lineno + .lineno)::before { top: auto; bottom: 2px; line-height
 /* The rule between sites spans the tree's full width, through
    its 16px side padding. */
 .site + .site {
-  border-top: 1px solid var(--rule); margin: 6px -16px 0; padding: 6px 16px 0;
+  border-top: 1px solid var(--tree-rule); margin: 6px -16px 0; padding: 6px 16px 0;
 }
 button.lnum .lineno { width: 50px; padding-right: 19px; color: inherit; line-height: 32px; margin: -4px 0; }
 button.lnum[data-status="covered"] { background: var(--ok-tint); color: var(--ok); border-color: var(--ok); }
@@ -92,15 +134,16 @@ button.lnum[data-status="gaps"] { background: var(--bad); color: var(--on-status
 button.lnum:hover { filter: brightness(1.1); }
 button.lnum:focus-visible { outline: 3px solid var(--link); outline-offset: 2px; }
 .tree {
-  margin: 4px 20px 12px 72px; padding: 10px 16px; border: 1px solid var(--rule);
-  border-radius: 8px; background: var(--panel); line-height: 30px;
+  margin: 4px 20px 12px 120px; padding: 10px 16px; border: 1px solid var(--tree-rule);
+  border-radius: 8px; background: var(--tree-bg); color: var(--tree-fg); line-height: 30px;
+  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.25);
 }
 .row { display: grid; grid-template-columns: auto minmax(200px, 1fr) 70px 70px 160px; column-gap: 16px; }
-.row.headings { font-family: var(--font-body); font-size: 12px; color: var(--muted); }
+.row.headings { font-family: var(--font-body); font-size: 12px; color: var(--tree-muted); }
 .row.headings span:first-child { grid-column: span 2; }
 .row.headings span:nth-child(2), .row.headings span:nth-child(3) { text-align: right; }
 .operator { grid-column: span 2; font-weight: 600; }
-.branch { white-space: pre; color: var(--muted); margin-right: -16px; }
+.branch { white-space: pre; color: var(--tree-muted); margin-right: -16px; }
 .row .text { white-space: pre; }
 .row .truthy, .row .falsy { text-align: right; font-variant-numeric: tabular-nums; }
-.row .gap { color: var(--bad); }
+.row .gap { color: var(--tree-gap); font-weight: 600; }

data/lib/condition_coverage/html_file.rb

@@ -1,5 +1,7 @@
 require 'cgi/escape'
+require_relative 'html_nav'
 require_relative 'html_template'
+require_relative 'html_tree'
 
 module ConditionCoverage
   # One covered file's HTML page: its source, with the numbers
@@ -16,6 +18,7 @@ module ConditionCoverage
         'index' => "#{'../' * (path.count('/') + 1)}index.html",
         'style' => HtmlTemplate.asset('style.css'),
         'script' => HtmlTemplate.asset('toggle.js'),
+        'jumps' => HtmlNav.jumps(lines),
         'listing' => listing(lines, trees)
       )
     end
@@ -28,30 +31,36 @@ module ConditionCoverage
       blocks = lines.chunk_while do |line, following|
         line[:span] && line[:span] == following[:span]
       end
-      body = blocks.map { |block| block(block, trees) }.join("\n")
-      %(<div class="code">\n#{body}\n</div>)
+      gaps = HtmlNav.gap_lines(blocks)
+      body = blocks.map { |block| block(block, trees, gaps) }
+      %(<div class="code">\n#{body.join("\n")}\n</div>)
     end
 
     # A plain line, or the lines of one span behind one button
-    # with the span's tree straight after them.
-    def self.block(lines, trees)
+    # with the span's tree straight after them; either way after
+    # its nav cell.
+    def self.block(lines, trees, gaps)
       first = lines[0]
-      return plain_line(first) if first[:span].nil?
-
       number = first[:number]
+      cell = HtmlNav.cell(number, gaps)
+      return plain_line(first, cell) if first[:span].nil?
+
       site_trees = trees.fetch(number, [])
-      span_block(lines, site_trees.size) + tree(number, site_trees)
+      open = first[:status] == :gaps
+      span_block(lines, site_trees.size, cell) +
+        HtmlTree.of(number, site_trees, open)
     end
 
-    # The lines of one span: one button over all their numbers,
-    # and how many sites it opens when that is two or more,
-    # beside their code.
-    def self.span_block(lines, sites)
+    # The lines of one span after their nav cell: one button over
+    # all their numbers, and how many sites it opens when that is
+    # two or more, beside their code.
+    def self.span_block(lines, sites, cell)
       numbers = lines.map { |line| number(line[:number]) }.join
       codes = lines.map { |line| code(line) }.join
       srcs = %(<div class="srcs">#{codes}</div>)
       content = site_count(sites) + numbers
-      %(<div class="block">#{button(lines[0], content)}#{srcs}</div>)
+      button = button(lines[0], content)
+      %(<div class="block">#{cell}#{button}#{srcs}</div>)
     end
 
     # The count of a button's sites, shown only for two or more.
@@ -61,93 +70,28 @@ module ConditionCoverage
       %(<span class="site-count" data-site-count="">#{sites}</span>)
     end
 
-    HEADINGS = %w[condition true false gap].freeze
-
-    # The hidden tree of a span: a heading row, then each site's
-    # rows in a group of their own.
-    def self.tree(number, site_trees)
-      groups = site_trees.map do |site|
-        rows = site_rows(site).join
-        %(<div class="site" data-site="">#{rows}</div>)
-      end
-      id = "tree-#{number}"
-      body = [heading_row, *groups].join
-      %(<div class="tree" id="#{id}" hidden="hidden">#{body}</div>)
-    end
-
-    # The row naming each column of a tree.
-    def self.heading_row
-      cells = HEADINGS.map { |name| %(<span>#{name}</span>) }.join
-      %(<div class="row headings" data-heading="">#{cells}</div>)
-    end
-
-    # A site's operator row, then the rows of its operands.
-    def self.site_rows(site)
-      row = %(<div class="row">#{operator(site)}</div>)
-      [row, *operand_rows(site, '')]
-    end
-
-    # The rows of a condition's operands, each branching from
-    # its operator after indent; a nested condition's operands
-    # follow its own row, indented under its branch.
-    def self.operand_rows(condition, indent)
-      last = condition[:operands].size - 1
-      condition[:operands].each_with_index.flat_map do |operand, i|
-        tip = i == last
-        branch = indent + (tip ? '└─ ' : '├─ ')
-        next [operand_row(operand, branch)] unless operand[:operator]
-
-        nested = operand_rows(operand, indent + (tip ? '   ' : '│  '))
-        [subtree_row(operand, branch), *nested]
-      end
-    end
-
-    # A nested condition's row: its branch and its operator.
-    def self.subtree_row(condition, branch)
-      cells = branch_cell(branch) + operator(condition)
-      %(<div class="row" data-subtree="">#{cells}</div>)
-    end
-
-    # The cell naming a condition's operator.
-    def self.operator(condition)
-      name = CGI.escapeHTML(condition[:operator])
-      %(<span class="operator" data-operator="">#{name}</span>)
-    end
-
-    # One operand's row: its branch, text, true and false
-    # counts, and gap.
-    def self.operand_row(operand, branch)
-      cells = %i[text truthy falsy gap].map do |name|
-        value = CGI.escapeHTML(operand[name].to_s)
-        %(<span class="#{name}" data-#{name}="">#{value}</span>)
-      end
-      lead = branch_cell(branch)
-      %(<div class="row" data-operand="">#{lead}#{cells.join}</div>)
-    end
-
-    # The cell drawing a row's branch from its operator.
-    def self.branch_cell(branch)
-      %(<span class="branch" data-branch="">#{branch}</span>)
-    end
-
-    # A line with no condition: its number, then its code.
-    def self.plain_line(line)
-      %(<div class="line">#{number(line[:number])}#{code(line)}</div>)
+    # A line with no condition: its nav cell, number and code.
+    def self.plain_line(line, cell)
+      parts = cell + number(line[:number]) + code(line)
+      %(<div class="line">#{parts}</div>)
     end
 
-    # The closed button over a span's numbers, opening the tree
-    # named after its first line.
+    # The button over a span's numbers, toggling the tree named
+    # after its first line; expanded when that tree starts open.
     def self.button(first, numbers)
+      expanded = first[:status] == :gaps
       [
         %(<button type="button" class="lnum"),
-        %( data-status="#{first[:status]}" aria-expanded="false"),
+        %( data-status="#{first[:status]}"),
+        %( aria-expanded="#{expanded}"),
         %( aria-controls="tree-#{first[:number]}">#{numbers}</button>)
       ].join
     end
 
-    # One line's number.
+    # One line's number, the target of a link to #L<number>.
     def self.number(number)
-      %(<span class="lineno" data-line="#{number}">#{number}</span>)
+      attributes = %(id="L#{number}" data-line="#{number}")
+      %(<span class="lineno" #{attributes}>#{number}</span>)
     end
 
     # One line's code, escaped.

data/lib/condition_coverage/html_nav.rb

@@ -0,0 +1,67 @@
+module ConditionCoverage
+  # The ways around a file's page: the header's lists of links to
+  # each span, and the arrows between the spans with gaps.
+  module HtmlNav
+    JUMP_LISTS = { 'covered' => 'Covered', 'gaps' => 'Gaps' }.freeze
+
+    # The header's lists of links to the first line of each span:
+    # those covered, then those with gaps.
+    def self.jumps(lines)
+      firsts = lines.select { |line| first_of_span?(line) }
+      lists = JUMP_LISTS.map do |status, label|
+        spans = firsts.select { |line| line[:status].to_s == status }
+        jump_list(status, label, spans.map { |line| line[:number] })
+      end
+      %(<nav class="jumps" aria-label="Sites">#{lists.join}</nav>)
+    end
+
+    # True for the line a span starts on.
+    def self.first_of_span?(line)
+      line[:span]&.begin == line[:number]
+    end
+
+    # One labelled list of links to lines.
+    def self.jump_list(status, label, numbers)
+      links = numbers.map { |number| jump(status, number) }
+      name = %(<span class="jump-label">#{label}</span>)
+      list = %(<div class="jump-list" data-jumps="#{status}">)
+      "#{list}#{name}#{links.join}</div>"
+    end
+
+    # One link to a line.
+    def self.jump(status, number)
+      attributes = %(data-status="#{status}" href="#L#{number}")
+      %(<a class="jump" #{attributes}>#{number}</a>)
+    end
+
+    # The first line of each span whose sites have gaps, given the
+    # listing's blocks.
+    def self.gap_lines(blocks)
+      firsts = blocks.map(&:first)
+      firsts.select { |line| line[:status] == :gaps }.map do |line|
+        line[:number]
+      end
+    end
+
+    # The cell left of a row's number: at a span with gaps, links
+    # to the previous and next such span, wrapping round at the
+    # ends; empty on every other row, so the numbers stay aligned.
+    def self.cell(number, gaps)
+      index = gaps.index(number)
+      links = index ? arrows(gaps, index) : ''
+      %(<span class="nav" data-nav="">#{links}</span>)
+    end
+
+    # The links to the spans with gaps either side of gaps[index].
+    def self.arrows(gaps, index)
+      previous = gaps[index - 1]
+      following = gaps[(index + 1) % gaps.size]
+      [
+        %(<a data-prev="" href="#L#{previous}"),
+        %( aria-label="Previous gap, line #{previous}">&#9650;</a>),
+        %(<a data-next="" href="#L#{following}"),
+        %( aria-label="Next gap, line #{following}">&#9660;</a>)
+      ].join
+    end
+  end
+end

data/lib/condition_coverage/html_tree.rb

@@ -0,0 +1,77 @@
+require 'cgi/escape'
+
+module ConditionCoverage
+  # The tree of a span's sites on a file's page, from SiteTree.of
+  # for each site.
+  module HtmlTree
+    HEADINGS = %w[condition true false gap].freeze
+
+    # The tree of a span, open when its sites have gaps, else
+    # hidden: a heading row, then each site's rows in a group of
+    # their own.
+    def self.of(number, site_trees, open)
+      groups = site_trees.map do |site|
+        rows = site_rows(site).join
+        %(<div class="site" data-site="">#{rows}</div>)
+      end
+      hidden = open ? '' : ' hidden="hidden"'
+      body = [heading_row, *groups].join
+      %(<div class="tree" id="tree-#{number}"#{hidden}>#{body}</div>)
+    end
+
+    # The row naming each column of a tree.
+    def self.heading_row
+      cells = HEADINGS.map { |name| %(<span>#{name}</span>) }.join
+      %(<div class="row headings" data-heading="">#{cells}</div>)
+    end
+
+    # A site's operator row, then the rows of its operands.
+    def self.site_rows(site)
+      row = %(<div class="row">#{operator(site)}</div>)
+      [row, *operand_rows(site, '')]
+    end
+
+    # The rows of a condition's operands, each branching from
+    # its operator after indent; a nested condition's operands
+    # follow its own row, indented under its branch.
+    def self.operand_rows(condition, indent)
+      last = condition[:operands].size - 1
+      condition[:operands].each_with_index.flat_map do |operand, i|
+        tip = i == last
+        branch = indent + (tip ? '└─ ' : '├─ ')
+        next [operand_row(operand, branch)] unless operand[:operator]
+
+        nested = operand_rows(operand, indent + (tip ? '   ' : '│  '))
+        [subtree_row(operand, branch), *nested]
+      end
+    end
+
+    # A nested condition's row: its branch and its operator.
+    def self.subtree_row(condition, branch)
+      cells = branch_cell(branch) + operator(condition)
+      %(<div class="row" data-subtree="">#{cells}</div>)
+    end
+
+    # The cell naming a condition's operator.
+    def self.operator(condition)
+      name = CGI.escapeHTML(condition[:operator])
+      %(<span class="operator" data-operator="">#{name}</span>)
+    end
+
+    # One operand's row: its branch, text, true and false
+    # counts, and gap.
+    def self.operand_row(operand, branch)
+      cells = %i[text truthy falsy gap].map do |name|
+        value = CGI.escapeHTML(operand[name].to_s)
+        %(<span class="#{name}" data-#{name}="">#{value}</span>)
+      end
+      lead = branch_cell(branch)
+      %(<div class="row" data-operand="">#{lead}#{cells.join}</div>)
+    end
+
+    # The cell drawing a row's branch from its operator.
+    def self.branch_cell(branch)
+      %(<span class="branch" data-branch="">#{branch}</span>)
+    end
+  end
+end

data/lib/condition_coverage/manifest.rb

@@ -19,7 +19,7 @@ module ConditionCoverage
       def initialize(path)
         @path = path
         @sites = {}
-        @commands = []
+        @notes = nil
         super()
       end
 
@@ -44,11 +44,11 @@ module ConditionCoverage
       def add_site(node)
         site = Site.of(@path, node)
         @sites[site] = nil
-        outer = @commands
-        @commands = []
+        outer = @notes
+        @notes = { commands: [], fixed: {} }
         condition = condition_of(node)
-        @sites[site] = condition.with(commands: @commands)
-        @commands = outer
+        @sites[site] = condition.with(**@notes)
+        @notes = outer
       end
 
       # node as a Condition, operands and all, named by its
@@ -77,16 +77,40 @@ module ConditionCoverage
       end
 
       # The byte range of a leaf operand, once any site inside
-      # it is noted too, and the range among its site's commands
-      # if it is a command call.
+      # it is noted too, and the range noted among its site's
+      # commands and fixed leaves where it is one.
       def leaf(operand)
         operand.accept(self)
         loc = operand.location
         range = loc.start_offset...loc.end_offset
-        @commands << range if command?(operand)
+        @notes[:commands] << range if command?(operand)
+        outcome = fixed_outcome(operand)
+        @notes[:fixed][range] = outcome if outcome
         range
       end
 
+      # A constant is taken to be truthy, as one holding nil or
+      # false is rare.
+      TRUTHY_TYPES = %i[
+        string_node integer_node symbol_node array_node hash_node
+        true_node lambda_node constant_read_node constant_path_node
+      ].freeze
+      FALSY_TYPES = %i[nil_node false_node].freeze
+
+      # The one outcome a leaf can have, eg :truthy for `Clock.new`
+      # or a literal, :falsy for `nil`; nil for a leaf that can
+      # have either.
+      def fixed_outcome(node)
+        return :falsy if FALSY_TYPES.include?(node.type)
+
+        :truthy if TRUTHY_TYPES.include?(node.type) || new_call?(node)
+      end
+
+      # True for a call to new, eg `Clock.new`.
+      def new_call?(node)
+        node.type == :call_node && node.name == :new
+      end
+
       # True for a call to a named method with arguments and no
       # parentheses, eg `id.include? 'N'`, but not `id.size == 6`.
       def command?(node)

data/lib/condition_coverage/result.rb

@@ -13,16 +13,26 @@ module ConditionCoverage
     end
 
     # { site => [counts of operand 0, counts of operand 1, ...] },
-    # with zero counts for an operand that never ran.
+    # with zero counts for an operand that never ran, and
+    # only: naming the one outcome a fixed leaf can have.
     def operands
       @sites.to_h do |site, condition|
-        size = condition.leaves.size
-        [site, Array.new(size) { |i| counts_of(site, i) }]
+        leaves = condition.leaves.each_with_index.map do |range, i|
+          leaf(site, condition, range, i)
+        end
+        [site, leaves]
       end
     end
 
     private
 
+    # The counts of one leaf, with only: when it is fixed.
+    def leaf(site, condition, range, index)
+      counts = counts_of(site, index)
+      only = condition.fixed[range]
+      only ? counts.merge(only:) : counts
+    end
+
     # The recorded counts of one operand, or zeros.
     def counts_of(site, index)
       @counts.fetch([site, index], NEVER_RAN)

data/lib/condition_coverage/source_lines.rb

@@ -1,3 +1,5 @@
+require_relative 'gaps'
+
 module ConditionCoverage
   # The lines of one file's page, each with the status of the
   # conditions on it.
@@ -58,14 +60,10 @@ module ConditionCoverage
       [one, other].include?(:gaps) ? :gaps : :covered
     end
 
-    # :covered when every operand was seen both ways, else :gaps.
+    # :covered when no operand has a gap, else :gaps.
     def self.status_of(counts)
-      counts.all? { |operand| seen_both?(operand) } ? :covered : :gaps
-    end
-
-    # True when the operand was seen both true and false.
-    def self.seen_both?(counts)
-      counts[:truthy].positive? && counts[:falsy].positive?
+      gaps = counts.flat_map { |operand| Gaps.operand_gap(operand) }
+      gaps.empty? ? :covered : :gaps
     end
 
     # The line a site starts on, from its path:line:column name.

data/lib/condition_coverage/summary.rb

@@ -10,7 +10,7 @@ module ConditionCoverage
     # The summary row of one file's sites.
     def self.row(path, sites)
       operands = sites.flat_map { |_, counts| counts }
-      outcomes = operands.size * 2
+      outcomes = operands.sum { |counts| counts[:only] ? 1 : 2 }
       seen = operands.sum { |counts| seen_in(counts) }
       {
         path:, sites: sites.size, seen:, outcomes:,

data/lib/condition_coverage/version.rb

@@ -1,3 +1,3 @@
 module ConditionCoverage
-  VERSION = '0.0.3'.freeze
+  VERSION = '0.0.5'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: condition_coverage
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Jon Jagger
@@ -42,8 +42,10 @@ files:
 - lib/condition_coverage/html/toggle.js
 - lib/condition_coverage/html_file.rb
 - lib/condition_coverage/html_index.rb
+- lib/condition_coverage/html_nav.rb
 - lib/condition_coverage/html_report.rb
 - lib/condition_coverage/html_template.rb
+- lib/condition_coverage/html_tree.rb
 - lib/condition_coverage/json_writer.rb
 - lib/condition_coverage/kernel.rb
 - lib/condition_coverage/manifest.rb