condition_coverage 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb36ad570a0050db876bba37548a59c929604eb35b88ed4b8ac4a155dde4db6e
-  data.tar.gz: 77f2dd1b7da7815a216fac0bee73f251f1c8d2c9490ad416d26125ac1adcfbe8
+  metadata.gz: a61c323a92442b231f61a10ea7ee622ee5e3b957f9818819e56aefda2ed75efd
+  data.tar.gz: eba0b9b94f2ba0756f0549d9675a4d3cb4c548df4854114df6e76e7ce09cdbeb
 SHA512:
-  metadata.gz: 5571a2753478ab9ed18b6a1e04b47df6f4f96b03f10637ac9bf8e0ad4149b8a02d6b6abf754b45e533c0eb37a417fffe9a7a937c3c86a6bf15b51fe13d2bed03
-  data.tar.gz: 5d97b90e7c1bff46242a833f234ef1a5ef62e8732bd2a2fe3f9b1f65fe441b0bcad5da1eeaf2ad0912ae7406ce3baf1c77067571b0751e6a9c6f602e831eca62
+  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.4 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).
 
@@ -77,8 +77,9 @@ 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`) and lambdas can only be truthy; `nil` and
-`false` only falsy:
+`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
@@ -92,7 +93,10 @@ its other outcome is impossible, not a gap. `Foo.new`, literals (`'s'`,
   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/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

@@ -89,9 +89,11 @@ module ConditionCoverage
         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
+        true_node lambda_node constant_read_node constant_path_node
       ].freeze
       FALSY_TYPES = %i[nil_node false_node].freeze
 

data/lib/condition_coverage/version.rb

@@ -1,3 +1,3 @@
 module ConditionCoverage
-  VERSION = '0.0.4'.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.4
+  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