path_coverage 0.1.0 → 0.2.0

data/lib/path_coverage/configuration.rb

@@ -1,21 +1,30 @@
+require_relative 'configuration_paths'
+
 module PathCoverage
   # Raised for a start block that cannot be applied.
   class ConfigurationError < StandardError; end
 
   # The settings given in a PathCoverage.start block.
   class Configuration
+    include ConfigurationPaths
+
     GLOB_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB
     SETTINGS = %w[
-      collector cover coverage_dir measure report root
+      collector cover coverage_dir group ignore measure report root
+      skip treat
     ].freeze
-    REPORTERS = %w[gaps html post].freeze
+    REPORTERS = %w[gaps html post summary].freeze
     MEASURES = %w[decisions methods].freeze
 
     # Evaluates the settings block against a new configuration.
     def initialize(&)
       @globs = []
+      @skips = []
+      @groups = {}
       @reporters = [:gaps]
       @measures = [:decisions]
+      @ignored = []
+      @treats = []
       instance_eval(&)
     end
 
@@ -29,7 +38,7 @@ module PathCoverage
 
     # Chooses what is measured.
     # Eg measure :decisions, :methods also measures the paths
-    # across each method's decisions.
+    # within each method, through its decisions.
     # Refuses a name there is no measure for.
     def measure(*names)
       check('measure', names, MEASURES)
@@ -60,6 +69,23 @@ module PathCoverage
       @globs << glob
     end
 
+    # Adds a glob, relative to root, of files not to instrument,
+    # though a cover glob matches them, eg skip 'source/vendor/**'.
+    def skip(glob)
+      @skips << glob
+    end
+
+    # { name => [glob, ...] } of each group given, in order.
+    # Eg { 'Models' => ['source/models/**/*.rb'] }.
+    attr_reader :groups
+
+    # Names a group of covered files, those matching any of
+    # globs, relative to root, so the HTML index gives them a
+    # tab of their own, eg group 'Models', 'source/models/**'.
+    def group(name, *globs)
+      @groups[name] = globs
+    end
+
     # Chooses the reporters run at exit, eg report :gaps;
     # refuses a name there is no reporter for.
     def report(*names)
@@ -86,10 +112,11 @@ module PathCoverage
       @coverage_dir = dir
     end
 
-    # Every file the cover globs match under root, as full
-    # paths, whether or not the run loads it.
+    # Every file the cover globs match under root, and no skip
+    # glob does, as full paths, whether or not the run loads it.
     def files
-      Dir.glob(@globs, base: @root).sort.map { |f| "#{@root}/#{f}" }
+      found = Dir.glob(@globs, base: @root).sort
+      found.reject { |f| skipped?(f) }.map { |f| "#{@root}/#{f}" }
     end
 
     # Where the JSON report goes.
@@ -102,13 +129,23 @@ module PathCoverage
       path.start_with?("#{@root}/") && matches?(relative(path))
     end
 
-    # True when the root-relative path matches a cover glob.
+    # True when the root-relative path matches a cover glob and
+    # no skip glob.
     def matches?(relative_path)
+      return false if skipped?(relative_path)
+
       @globs.any? do |glob|
         File.fnmatch?(glob, relative_path, GLOB_FLAGS)
       end
     end
 
+    # True when the root-relative path matches a skip glob.
+    def skipped?(relative_path)
+      @skips.any? do |glob|
+        File.fnmatch?(glob, relative_path, GLOB_FLAGS)
+      end
+    end
+
     # path relative to root, eg "source/kata.rb".
     def relative(path)
       path.delete_prefix("#{@root}/")

data/lib/path_coverage/configuration_paths.rb

@@ -0,0 +1,56 @@
+require_relative 'kinds'
+
+module PathCoverage
+  # The settings of a PathCoverage.start block that change which
+  # paths a site has: ignore, eg ignore '&&=', and treat, eg
+  # treat 'name', as: :present. It relies on its includer's
+  # @ignored, @treats and check.
+  module ConfigurationPaths
+    TREATMENTS = %w[present nonempty].freeze
+
+    # The operators whose sites are not measured, chosen with
+    # ignore, eg ['&&=']; none when nothing was chosen.
+    attr_reader :ignored
+
+    # Chooses operators whose sites are not measured, eg
+    # ignore '&&=' measures no &&= write; a site inside one, eg
+    # on its right side, still is. Refuses an operator there
+    # is no kind of site for.
+    def ignore(*operators)
+      check('operator', operators, Kinds::BY_OPERATOR.keys)
+      @ignored = operators
+    end
+
+    # Treats calls to the method named name as never nil, with
+    # as: :present, so a &. after such a call has no nil path;
+    # or as true exactly when its receiver has items, with as:
+    # :nonempty, eg any?. It applies in each covered file
+    # matching glob, relative to root, or in every one with no
+    # glob. Refuses any other treatment.
+    def treat(name, as:, in: nil)
+      check('treatment', [as], TREATMENTS)
+      @treats << [name, as.to_s, binding.local_variable_get(:in)]
+    end
+
+    # The names of the methods treated as as, eg 'present', in
+    # the covered file at relative_path.
+    def treated(as, relative_path)
+      flags = Configuration::GLOB_FLAGS
+      @treats.filter_map do |name, treatment, glob|
+        next unless treatment == as
+
+        name if glob.nil? || File.fnmatch?(glob, relative_path, flags)
+      end
+    end
+
+    # The settings that change which paths a site has, eg
+    # { 'ignored' => ['&&='],
+    #   'treats' => [['name', 'present', nil]] },
+    # each only when set: runs whose fingerprints differ list
+    # their sites' paths differently.
+    def fingerprint
+      all = { 'ignored' => @ignored, 'treats' => @treats }
+      all.reject { |_, setting| setting.empty? }
+    end
+  end
+end

data/lib/path_coverage/console_summary.rb

@@ -0,0 +1,77 @@
+require_relative 'summary'
+require_relative 'totals'
+
+module PathCoverage
+  # The :summary reporter's lines: each total as SimpleCov prints
+  # its line and branch coverage, eg
+  # "Path coverage within decisions: 519 / 623 (83.31%)". With
+  # groups configured each group is a heading, its own totals
+  # indented under it, and there is no total over every group.
+  module ConsoleSummary
+    # The summary lines of site_paths and, when paths are given,
+    # as they are when methods are measured, of methods; groups
+    # is { name => [glob, ...] }.
+    def self.lines(site_paths, methods, paths, groups = {})
+      if groups.empty?
+        return totals_lines(totals(site_paths, methods, paths))
+      end
+
+      all = group_totals(site_paths, methods, paths, groups)
+      all.flat_map do |name, totals|
+        ["#{name}:", *totals_lines(totals).map { |line| "  #{line}" }]
+      end
+    end
+
+    # { 'decisions' => [taken, possible] } of site_paths, with
+    # 'methods' => [taken, possible] of methods when paths are
+    # given.
+    def self.totals(site_paths, methods, paths)
+      totals = { 'decisions' => Totals.decisions(site_paths) }
+      return totals if paths.nil?
+
+      totals.merge('methods' => Totals.methods(methods, paths))
+    end
+
+    # { group name => totals } of each group's own sites and
+    # methods alone.
+    def self.group_totals(site_paths, methods, paths, groups)
+      groups.to_h do |name, globs|
+        own_sites = own(site_paths, globs)
+        [name, totals(own_sites, own(methods, globs), paths)]
+      end
+    end
+
+    # The entries of sites, keyed by site name, in a file matching
+    # any of globs.
+    def self.own(sites, globs)
+      sites.select do |site, _|
+        Summary.matches?(Summary.path_of(site), globs)
+      end
+    end
+
+    # The line naming the operators ignored, eg "Path coverage
+    # ignores: &&="; none when none are.
+    def self.ignored_lines(ignored)
+      return [] if ignored.empty?
+
+      ["Path coverage ignores: #{ignored.join(', ')}"]
+    end
+
+    # A line per total, eg "Path coverage within methods: 1 / 4
+    # (25.00%)".
+    def self.totals_lines(totals)
+      totals.map do |name, pair|
+        "Path coverage within #{name}: #{figure(pair)}"
+      end
+    end
+
+    # [taken, possible] as "taken / possible (percent)", its
+    # percent to two places, or - when no path is possible.
+    def self.figure((taken, possible))
+      return "#{taken} / #{possible} (-)" if possible.zero?
+
+      percent = format('%.2f%%', 100.0 * taken / possible)
+      "#{taken} / #{possible} (#{percent})"
+    end
+  end
+end

data/lib/path_coverage/gaps.rb

@@ -4,28 +4,44 @@ module PathCoverage
   # count stays in the operands and paths for reporters that
   # show them all.
   module Gaps
-    # The gap lines of operands and paths, as Result gives
-    # them, in manifest order; texts is { site => each leaf's
-    # source text }.
-    def self.lines(operands, paths: {}, texts: {})
+    # The gap lines of operands, paths and outside, as Result
+    # gives them, in manifest order; texts is { site => each
+    # leaf's source text }.
+    def self.lines(operands, paths: {}, texts: {}, outside: {})
       operands.flat_map do |site, counts|
         if counts.all? { |each| never_ran?(each) }
           next ["#{site} never reached"]
         end
 
-        path_gaps(site, paths.fetch(site, []), texts[site])
+        path_gaps(site, paths.fetch(site, []), texts[site]) +
+          ruled_out(site, outside.fetch(site, {}), texts[site])
       end
     end
 
+    # One line per path site took that a treatment rules out,
+    # as Result#outside gives them, texts being each leaf's
+    # source text.
+    def self.ruled_out(site, taken, texts)
+      taken.keys.map do |path|
+        "#{site} path taken that a treatment rules out: " \
+          "#{steps(path, texts)}"
+      end
+    end
+
+    # The outcome of each leaf path reaches, each named by its
+    # text, eg "`u.name` nil".
+    def self.steps(path, texts)
+      path.zip(texts).filter_map do |outcome, text|
+        "#{code(text)} #{outcome}" unless outcome.nil?
+      end.join(', ')
+    end
+
     # One line per path site never took, as Result#paths gives
     # them, naming the outcome of each leaf the path reaches,
     # texts being each leaf's source text.
     def self.path_gaps(site, paths, texts)
       paths.select { |each| each[:count].zero? }.map do |each|
-        steps = each[:path].zip(texts).filter_map do |outcome, text|
-          "#{code(text)} #{outcome}" unless outcome.nil?
-        end
-        "#{site} path never taken: #{steps.join(', ')}"
+        "#{site} path never taken: #{steps(each[:path], texts)}"
       end
     end
 

data/lib/path_coverage/html/index.html

@@ -13,24 +13,10 @@
 <body>
 <main class="page">
 <h1>Path coverage</h1>
+{{tabs}}
 <div class="box">
-<table id="files">
-<thead>
-<tr>
-<th aria-sort="none"><button type="button" data-column="0" data-type="text">File</button></th>
-<th class="num" aria-sort="none"><button type="button" data-column="1" data-type="number">Sites</button></th>
-<th class="num" aria-sort="none"><button type="button" data-column="2" data-type="number">Within each decision</button></th>
-{{across}}
-</tr>
-</thead>
-<tbody>
-{{rows}}
-</tbody>
-<tfoot>
-{{total}}
-</tfoot>
-</table>
-</div>
+{{tables}}
+</div>{{ignored}}
 </main>
 <script>
 //<![CDATA[

data/lib/path_coverage/html/side.js

@@ -56,10 +56,12 @@
   }
 
   // Opens panel, a tree or a grid, alone; null closes all. Any
-  // path shown or pinned goes with the grid it was in.
+  // path shown or pinned goes with the grid it was in. The box
+  // drops any height a tree it held gave it.
   function openOnly(panel) {
     pin(null);
     clear();
+    box.style.minHeight = '';
     trees.forEach(function (tree) {
       tree.hidden = tree !== panel;
       buttonOf(tree).setAttribute('aria-expanded', tree === panel ? 'true' : 'false');
@@ -70,10 +72,24 @@
       bands[i].classList.toggle('open', grid === panel);
     });
     var side = !panel ? '' : panel.classList.contains('tree') ? 'cc' : 'pc';
+    fitRail(side === 'cc' ? panel : null);
     document.body.setAttribute('data-open', side);
     slide(panel);
   }
 
+  // The narrowest the condition rail opens to, as style.css has it.
+  var RAIL_MIN = 560;
+
+  // Widens the condition rail to tree's own width, so a tree with
+  // many paths or long labels sits wholly beside the code; null,
+  // for no tree open, gives the rail back its own width.
+  function fitRail(tree) {
+    var style = document.body.style;
+    if (!tree) { style.removeProperty('--cc-rail'); return; }
+    var width = Math.max(RAIL_MIN, Math.ceil(tree.offsetWidth));
+    style.setProperty('--cc-rail', width + 'px');
+  }
+
   // Scrolls the page just enough to show all of panel when it
   // is a tree, eg one opened from a line near the bottom of the
   // window, so its last rows are not below the fold. Its first
@@ -101,13 +117,16 @@
 
   // Sets an open tree's top so its first site's row, naming its
   // operator and path counts, is level with the first line of
-  // its site's code.
+  // its site's code. The box grows to hold the whole tree, as
+  // one overflowing it would make the box scroll, sliding the
+  // code's first lines out of sight.
   function placeTree(tree) {
     var block = buttonOf(tree).closest('.block');
     tree.style.top = '0px';
     var line = spot(block.querySelector('.src'), ccRail).middle;
     var row = spot(tree.querySelector('.site .row'), tree).middle;
     tree.style.top = (line - row) + 'px';
+    box.style.minHeight = Math.ceil(spot(tree, box).bottom) + 'px';
   }
 
   // Sets an open grid's top level with its def, its calls row

data/lib/path_coverage/html/sort.js

@@ -1,30 +1,33 @@
-// Sorts the files table by the clicked column's data-sort values;
+// Sorts a files table by the clicked column's data-sort values;
 // a second click on the same column reverses the order. A cell
 // with an empty data-sort, one with no value such as a -, stays
 // last in both orders, so either end of the values can be first.
+// Each table, one per tab, sorts on its own.
 (function () {
-  var table = document.getElementById('files');
-  var body = table.tBodies[0];
-  var state = { column: -1, ascending: true };
+  document.querySelectorAll('table.files').forEach(function (table) {
+    var body = table.tBodies[0];
+    var state = { column: -1, ascending: true };
 
-  table.querySelectorAll('thead button').forEach(function (button) {
-    button.addEventListener('click', function () {
-      var column = Number(button.dataset.column);
-      var numeric = button.dataset.type === 'number';
-      state.ascending = state.column === column ? !state.ascending : true;
-      state.column = column;
-      var rows = Array.from(body.rows);
-      rows.sort(function (a, b) {
-        var x = a.cells[column].dataset.sort;
-        var y = b.cells[column].dataset.sort;
-        if (x === '' || y === '') { return (x === '') - (y === ''); }
-        var order = numeric ? Number(x) - Number(y) : x.localeCompare(y);
-        return state.ascending ? order : -order;
-      });
-      rows.forEach(function (row) { body.appendChild(row); });
-      table.querySelectorAll('thead th').forEach(function (th, i) {
+    table.querySelectorAll('thead button').forEach(function (button) {
+      button.addEventListener('click', function () {
+        var column = Number(button.dataset.column);
+        var numeric = button.dataset.type === 'number';
+        state.ascending = state.column === column ? !state.ascending : true;
+        state.column = column;
+        var rows = Array.from(body.rows);
+        rows.sort(function (a, b) {
+          var x = a.cells[column].dataset.sort;
+          var y = b.cells[column].dataset.sort;
+          if (x === '' || y === '') { return (x === '') - (y === ''); }
+          var order = numeric ? Number(x) - Number(y) : x.localeCompare(y);
+          return state.ascending ? order : -order;
+        });
+        rows.forEach(function (row) { body.appendChild(row); });
         var sort = state.ascending ? 'ascending' : 'descending';
-        th.setAttribute('aria-sort', i === column ? sort : 'none');
+        table.querySelectorAll('thead button').forEach(function (other) {
+          var mine = Number(other.dataset.column) === column;
+          other.parentNode.setAttribute('aria-sort', mine ? sort : 'none');
+        });
       });
     });
   });

data/lib/path_coverage/html/style.css

@@ -50,7 +50,22 @@ td:first-child { font-family: var(--font-code); }
    head, so it reads as a sum, not as one more file. */
 tfoot td { background: var(--panel); font-weight: 600; border-top: 1px solid var(--fg); }
 tfoot td:first-child { font-family: inherit; }
+/* The index page's tabs, one per group of files; the selected
+   one framed as the table's headings are. */
+.tabs { display: flex; flex-wrap: wrap; gap: 4px; margin: 0 0 8px; }
+.tabs [role="tab"] { font: inherit; font-size: 13px; padding: 6px 12px; border: 1px solid var(--rule); border-radius: 6px; background: var(--surface); color: var(--muted); cursor: pointer; }
+.tabs [role="tab"][aria-selected="true"] { background: var(--panel); color: var(--fg); border-color: var(--fg); font-weight: 600; }
+.tabs [role="tab"]:focus-visible { outline: 3px solid var(--link); outline-offset: 2px; }
 .num, td:not(:first-child) { text-align: right; }
+/* A total's taken, / of and % sit close, so a row still reads
+   3 / 4 75%; its name heads all three. The File column takes
+   the table's spare width, so it never spreads them apart. */
+table.files tr > :first-child { width: 100%; }
+table.files th, table.files td:not(:first-child) { white-space: nowrap; }
+th.group { text-align: center; padding-bottom: 0; }
+.taken { text-align: right; padding-left: 32px; padding-right: 4px; }
+td.of, th.of { text-align: left; padding-left: 0; padding-right: 6px; }
+.percent { text-align: right; padding-left: 6px; }
 th button {
   font: 600 13px var(--font-body); color: var(--fg); background: none; border: 0;
   padding: 4px 0; cursor: pointer;
@@ -203,6 +218,8 @@ body[data-layout="beside"] .box:has(> .code) {
 body[data-layout="beside"] .code {
   min-width: 0; overflow-x: auto;
   display: grid; grid-template-columns: minmax(max-content, 1fr);
+  /* Lines keep their height when the box grows to hold a tree. */
+  align-content: start;
 }
 body[data-layout="beside"] .box:has(> .code)::before {
   left: calc(var(--cc-rail) + 38px); right: calc(var(--pc-rail) + 12px);
@@ -217,7 +234,17 @@ body[data-layout="beside"] .box:has(> .code)::before {
 /* The rail's tree has narrower columns, to fit its width; a
    thin rule under each site's counts row, across the tree's
    full width through its 16px side padding. */
-.rail .row { grid-template-columns: auto minmax(120px, 1fr); grid-auto-columns: 26px; column-gap: 8px; }
+/* Each row lays its branch and label out at their own width, the
+   label pushing its cells to the row's right edge, so a site's
+   cells line up in columns however long or deep its labels. */
+.rail .row { display: flex; align-items: center; gap: 8px; }
+.rail .row > :is(.text, .arm, .operator) { margin-right: auto; padding-right: 8px; }
+/* An explicit width, not just a flex basis, so a row's natural
+   width counts each cell as 26px, not as its one letter. */
+.rail .row > :is(.cell, .count) { flex: none; width: 26px; }
+/* The tree is as wide as its widest row, and at least the rail;
+   side.js widens the rail to it. */
+.rail .tree { width: max-content; min-width: 100%; right: auto; }
 .rail .site > .row:first-child {
   border-bottom: 1px solid var(--tree-rule); margin: 0 -16px 6px; padding: 0 16px 4px;
 }

data/lib/path_coverage/html/tabs.js

@@ -0,0 +1,15 @@
+// Switches the index page's tabs: a click on a tab selects it and
+// shows the table it controls, hiding every other tab's table.
+(function () {
+  var tabs = Array.from(document.querySelectorAll('[role="tab"]'));
+  tabs.forEach(function (tab) {
+    tab.addEventListener('click', function () {
+      tabs.forEach(function (other) {
+        var selected = other === tab;
+        other.setAttribute('aria-selected', selected ? 'true' : 'false');
+        var table = document.getElementById(other.getAttribute('aria-controls'));
+        table.hidden = !selected;
+      });
+    });
+  });
+})();

data/lib/path_coverage/html_index.rb

@@ -1,29 +1,76 @@
 require 'cgi/escape'
+require_relative 'html_index_head'
+require_relative 'html_tabs'
 require_relative 'html_template'
 
 module PathCoverage
   # The HTML index page: one sortable row per covered file,
-  # each linking to that file's own page, then a Total row.
+  # each linking to that file's own page, then a Total row; with
+  # groups, one such table per tab.
   module HtmlIndex
-    # The whole index page: the files table, sortable by any
-    # column, with one row per Summary.files row, and total, as
-    # Summary.total gives it, as its footer.
-    def self.page(rows, total)
+    # The whole index page. rows are Summary.files rows and total
+    # their Summary.total. groups are [name, rows, total] for
+    # each group, each given a tab after All files; with none
+    # there is no tab bar, just the one table. Any operators
+    # ignored are named after the tables.
+    def self.page(rows, total, groups = [], ignored: [])
+      tables = [['All files', rows, total], *groups]
+      names = tables.map(&:first)
       HtmlTemplate.fill(
         HtmlTemplate.asset('index.html'),
         'style' => HtmlTemplate.asset('style.css'),
-        'script' => HtmlTemplate.asset('sort.js'),
-        'rows' => rows.map { |row| row(row) }.join("\n"),
-        'total' => total_row(total),
-        'across' => total[:methods] ? ACROSS : ''
+        'script' => script(groups),
+        'tabs' => groups.empty? ? '' : HtmlTabs.bar(names),
+        'tables' => tables_of(tables),
+        'ignored' => ignored_line(ignored)
       )
     end
 
-    # The heading of the across column, there only when methods
-    # are measured.
-    ACROSS = '<th class="num" aria-sort="none"><button ' \
-             'type="button" data-column="3" data-type="number">' \
-             "Across a method's decisions</button></th>".freeze
+    # The paragraph naming the operators ignored, eg
+    # "Ignored: &&="; empty when none are.
+    def self.ignored_line(ignored)
+      return '' if ignored.empty?
+
+      text = CGI.escapeHTML("Ignored: #{ignored.join(', ')}")
+      %(<p class="ignored" data-ignored="">#{text}</p>)
+    end
+
+    # Each of tables, [name, rows, total], as the table of its
+    # tab.
+    def self.tables_of(tables)
+      tables.each_with_index.map do |(_, rows, total), index|
+        table(index, rows, total)
+      end.join("\n")
+    end
+
+    # The page's script: its column sorting, and, with groups,
+    # its tab switching.
+    def self.script(groups)
+      sort = HtmlTemplate.asset('sort.js')
+      groups.empty? ? sort : sort + HtmlTemplate.asset('tabs.js')
+    end
+
+    # The index-th tab's table of rows, total as its footer; any
+    # but the first starts hidden.
+    def self.table(index, rows, total)
+      body = rows.map { |row| row(row) }.join("\n")
+      head = HtmlIndexHead.of(total[:methods])
+      [
+        open_tag(index),
+        "<thead>\n#{head}\n</thead>",
+        "<tbody>\n#{body}\n</tbody>",
+        "<tfoot>\n#{total_row(total)}\n</tfoot>",
+        '</table>'
+      ].join("\n")
+    end
+
+    # The opening tag of the index-th tab's table, which the tab
+    # of the same index controls; any but the first is hidden.
+    def self.open_tag(index)
+      hidden = index.zero? ? '' : ' hidden="hidden"'
+      id = %(id="files-#{index}")
+      %(<table class="files" #{id} role="tabpanel"#{hidden}>)
+    end
 
     # The table row of one Summary.files row; each cell has a
     # data-sort value for the page's column sorting.
@@ -33,42 +80,50 @@ module PathCoverage
       "<tr>#{cell(path, link)}#{counts(row).join}</tr>"
     end
 
-    # The footer row: the sums over every file.
+    # The footer row: the sums over the table's files.
     def self.total_row(total)
       "<tr>#{cell('Total', 'Total')}#{counts(total).join}</tr>"
     end
 
     # The cells after the file's: its sites, then its total
     # within each decision, then, when methods are measured, its
-    # total across a method's decisions.
+    # total within each method.
     def self.counts(row)
       cells = [
         cell(row[:sites], row[:sites]),
-        paths_cell(row[:decisions])
+        *paths_cells(row[:decisions], 'no decisions')
       ]
-      row[:methods] ? cells + [paths_cell(row[:methods])] : cells
+      return cells unless row[:methods]
+
+      none = 'no method with two or more decisions'
+      cells + paths_cells(row[:methods], none)
     end
 
-    # A cell showing [taken, possible] paths, eg 3 / 6 (50%),
-    # sorted by its percent. With no paths to take, as in a file
-    # with no method of two or more decisions, it shows -,
-    # titled with why, with an empty sort value, which sort.js
-    # keeps last whichever way the column is sorted.
-    def self.paths_cell(pair)
+    # Three cells showing [taken, possible] paths, eg 3, / 6 and
+    # 50%, each sorted by its number, so they read 3 / 6 50%.
+    # With no paths to take, as in a group no file is in, or a
+    # file with no method of two or more decisions, the percent
+    # shows -, titled with none, saying why, with an empty sort
+    # value, which sort.js keeps last whichever way the column
+    # is sorted.
+    def self.paths_cells(pair, none)
       taken, possible = pair
-      if possible.zero?
-        return cell('', '-', 'no method with two or more decisions')
-      end
+      counts = [cell(taken, taken, css: 'taken'),
+                cell(possible, "/ #{possible}", css: 'of')]
+      none_cell = cell('', '-', none, css: 'percent')
+      return [*counts, none_cell] if possible.zero?
 
       percent = (100.0 * taken / possible).round
-      cell(percent, "#{taken} / #{possible} (#{percent}%)")
+      [*counts, cell(percent, "#{percent}%", css: 'percent')]
     end
 
     # One table cell, sorted by sort_value, showing content,
-    # with title as its hover text when there is one.
-    def self.cell(sort_value, content, title = nil)
+    # with title as its hover text and css as its class, each
+    # when there is one.
+    def self.cell(sort_value, content, title = nil, css: nil)
       hover = title ? %( title="#{title}") : ''
-      %(<td data-sort="#{sort_value}"#{hover}>#{content}</td>)
+      klass = css ? %( class="#{css}") : ''
+      %(<td#{klass} data-sort="#{sort_value}"#{hover}>#{content}</td>)
     end
   end
 end