path_coverage 0.1.0 → 0.2.0

data/lib/path_coverage/kinds/block.rb

@@ -0,0 +1,136 @@
+require_relative 'base'
+
+module PathCoverage
+  module Kinds
+    # A block method's call, eg ids.any? { |id| id.odd? }: its
+    # receiver's count of items, and its block's answers, its
+    # value following from them. Nothing else is evaluated, eg
+    # ids.size.
+    module Block
+      extend Base
+
+      OPERATORS = BLOCK_PATHS.keys.freeze
+
+      # A value that holds whatever the path, eg select's array.
+      ALWAYS = ->(*) { true }
+
+      # nil, nothing found, when its block was called with no
+      # items or its last answer was false; else the item found,
+      # which may itself be nil, so nil, as no path can tell.
+      FOUND = ->(none, answer) { none || !answer ? false : nil }
+
+      # A block method's value from whether its block was called
+      # with no items, and its block's last answer; nil when the
+      # path cannot tell.
+      VALUES = {
+        'any?' => ->(none, answer) { !none && answer },
+        'all?' => ->(none, answer) { none || answer },
+        'none?' => ->(none, answer) { none || !answer },
+        'detect' => FOUND,
+        'find' => FOUND,
+        'find_index' => ->(none, answer) { !none && answer },
+        'take_while' => ALWAYS,
+        **EVERY_ITEM.to_h { |name| [name, ALWAYS] }
+      }.freeze
+
+      # Whether select's result has items: whether any answer
+      # was true.
+      KEPT = lambda do |items, answers|
+        items != ITEMS[0] && answers != ANSWERS[1]
+      end
+
+      # Whether a block method's result has items, from how many
+      # items its block was called with and its answers, eg
+      # select keeps an item when any answer was true; nil when
+      # its path cannot tell, eg take_while's last answer false
+      # after 2+ items, which may or may not be its first.
+      HAS_ITEMS = {
+        'select' => KEPT, 'filter' => KEPT, 'filter_map' => KEPT,
+        'reject' => lambda do |items, answers|
+          items != ITEMS[0] && answers != ANSWERS[0]
+        end,
+        'partition' => ALWAYS,
+        'take_while' => lambda do |items, answer|
+          next false if items == ITEMS[0]
+
+          answer || (items == ITEMS[1] ? false : nil)
+        end
+      }.freeze
+
+      # Whether site's result has items on the path that took
+      # outcomes; nil when its kind cannot tell, eg for a site
+      # that is no block method's call.
+      def self.items?(site, outcomes)
+        receiver, body = site.operands
+        rule = HAS_ITEMS[site.operator]
+        rule&.call(outcomes[receiver], outcomes[body])
+      end
+
+      # The ways node can be evaluated, fixed by its shape, its
+      # value following from each.
+      def self.ways(node, _fixed)
+        receiver, body = node.operands
+        BLOCK_PATHS[node.operator].map do |items, answer|
+          value = path_value(node.operator, items, answer)
+          [{ receiver => items, body => answer }, value]
+        end
+      end
+
+      # Its value on a path: its count of items and its block's
+      # answer, eg false for any? called with 0 items, and always
+      # truthy for select, which gives an array; nil for find
+      # with a last answer true, whose value no path can tell.
+      def self.path_value(operator, items, answer)
+        VALUES[operator].call(items == ITEMS[0], answer)
+      end
+
+      # Its value in each column, from its count of items and its
+      # block's answer there; nil where it was not reached.
+      def self.value(operator, operands)
+        receiver, body = operands
+        receiver[:cells].zip(body[:cells]).map do |items, answer|
+          items && path_value(operator, items, answer)
+        end
+      end
+
+      # Its block's opening and closing in source, ['{', '}'] or
+      # ['do', 'end']: the opening between its receiver and its
+      # block's expression, the closing after that expression.
+      def self.brackets(source, site)
+        receiver, body = site.operands
+        between = source.byteslice(receiver.end...body.begin)
+        closing = source.byteslice(body.end...site.extent.end)
+        [between[/\{|\bdo\b/], closing.strip]
+      end
+
+      # Its receiver needs no record call, and its block's
+      # expression an item_at or answer_at call.
+      def self.own_calls?
+        true
+      end
+
+      # The calls for its leaves: none for its receiver, whose
+      # leaf notes the items its block was called with, and an
+      # item_at call, noting its last answer, or for a method that
+      # calls it with every item an answer_at call, noting every
+      # answer, for its block's expression.
+      def self.calls(site, inner, leaves)
+        receiver, body = inner.operands
+        at = leaves.index(receiver)
+        every = EVERY_ITEM.include?(inner.operator)
+        noter = every ? 'answer_at' : 'item_at'
+        { receiver => nil,
+          body => "PathCoverage.#{noter}(#{site.inspect}, #{at}, " }
+      end
+
+      # Its call wrapped whole, its receiver the site's at-th leaf,
+      # so its items are begun before it runs and counted after.
+      def self.inserts(site, inner, at, _commands)
+        name = site.inspect
+        begun = "PathCoverage.begin_items(#{name}, #{at})"
+        call = "PathCoverage.end_items(#{name}, #{at}, #{begun}, "
+        Rewriter.wrap(call, inner.extent, false, :kind)
+      end
+    end
+  end
+end

data/lib/path_coverage/kinds/case.rb

@@ -0,0 +1,89 @@
+require_relative 'base'
+require_relative 'chain'
+
+module PathCoverage
+  module Kinds
+    # A case, its operands its whens' and else's arms, each when
+    # trying its patterns in turn until one matches. Each pattern
+    # is wrapped in a stand-in, which matches the case's subject
+    # against it once, as the case would have.
+    module Case
+      extend Base
+
+      OPERATORS = %w[case].freeze
+
+      # The ways node can be evaluated: as the chain of its whens'
+      # conditions.
+      def self.ways(node, fixed)
+        whens = node.operands.filter_map(&:body)
+        Chain.ways(node.with(operands: whens), fixed)
+      end
+
+      # The inserts that wrap each pattern of a case site in a
+      # when_match call, its stand-in, which enters and leaves the
+      # site itself, as the case tries its patterns one by one;
+      # its arms may return or raise, so no leave wraps it.
+      def self.site_inserts(site, condition)
+        size = condition.leaves.size
+        condition.leaves.each_with_index.flat_map do |range, index|
+          call = "PathCoverage.when_match(#{site.inspect}, " \
+                 "#{index}, #{size}, "
+          Rewriter.wrap(call, range, false, :leaf)
+        end
+      end
+
+      # Its node in a site's tree from its arms, built in order so
+      # its whens' patterns pair with path entries left to right:
+      # a when is taken on each path one of its patterns matched,
+      # and the else on each none did. A case's value is that of
+      # no choice, so is nil.
+      def self.node(source, condition, outcomes, leaves)
+        matched = []
+        operands = condition.operands.map do |arm|
+          arm_node(source, arm, matched, [outcomes, leaves])
+        end
+        cells = Array.new(outcomes.size)
+        { operator: 'case', cells:, operands: }
+      end
+
+      # One arm's node, its cells whether each column took it;
+      # matched holds the cells of each when before it, and a
+      # when's own are added.
+      def self.arm_node(source, arm, matched, (outcomes, leaves))
+        body = arm.body &&
+               SiteTree.node(source, arm.body, outcomes, leaves)
+        matched << body[:cells].map { |cell| cell == true } if body
+        cells = body ? matched.last : unmatched(matched, outcomes)
+        text = SiteTree.text_of(source, arm)
+        { arm: arm.kind, text:, cells:, body: }
+      end
+
+      # Whether each column matched none of its whens' patterns.
+      def self.unmatched(matched, outcomes)
+        outcomes.each_index.map do |column|
+          matched.none? { |taken| taken[column] }
+        end
+      end
+
+      # The name of one of its arms: when or else.
+      def self.arm_label(arm, _choice)
+        arm[:arm].to_s
+      end
+
+      # Its patterns need pattern calls.
+      def self.own_calls?
+        true
+      end
+
+      # { pattern range => the opening of its pattern call } for
+      # the patterns of inner, a case nested in a site whose leaves
+      # are leaves.
+      def self.calls(site, inner, leaves)
+        inner.leaves.to_h do |range|
+          index = leaves.index(range)
+          [range, "PathCoverage.pattern(#{site.inspect}, #{index}, "]
+        end
+      end
+    end
+  end
+end

data/lib/path_coverage/kinds/chain.rb

@@ -0,0 +1,45 @@
+require_relative 'base'
+
+module PathCoverage
+  module Kinds
+    # A chain of one operator, eg a && b && c, or a when's
+    # patterns, each operand reached only while every one before
+    # it gave the outcome its operator goes on with.
+    module Chain
+      extend Base
+
+      OPERATORS = %w[&& and || or when].freeze
+
+      # The outcome of an operand on which each operator goes on
+      # to its next operand; any other ends the chain there. A
+      # when's patterns, and a case's whens, stop at a match.
+      CONTINUES_ON = {
+        '&&' => true, 'and' => true, '||' => false, 'or' => false,
+        'when' => false, 'case' => false
+      }.freeze
+
+      # The ways node can be evaluated: each way of its first
+      # operand, going on to the next while each outcome is the
+      # one its operator goes on with.
+      def self.ways(node, fixed)
+        first, *rest = node.operands
+        goes_on = CONTINUES_ON.fetch(node.operator)
+        rest.reduce(SitePaths.walk(first, fixed)) do |ways, operand|
+          ways.flat_map do |outcomes, value|
+            next [[outcomes, value]] unless value == goes_on
+
+            SitePaths.walk(operand, fixed).map do |more, after|
+              [outcomes.merge(more), after]
+            end
+          end
+        end
+      end
+
+      # Its value in each column: the last operand it reached.
+      def self.value(_operator, operands)
+        operands.map { |operand| operand[:cells] }
+                .transpose.map { |column| column.compact.last }
+      end
+    end
+  end
+end

data/lib/path_coverage/kinds/choice.rb

@@ -0,0 +1,68 @@
+require_relative 'base'
+
+module PathCoverage
+  module Kinds
+    # The ways and value of a condition whose predicate picks an
+    # arm, which Choice and Write share.
+    module Arms
+      # The ways node can be evaluated: each way of its predicate,
+      # then each way of the condition the arm it picks is, if
+      # that arm is one; one with no else arm picks none. Its
+      # value is that of no choice, so is nil.
+      def ways(node, fixed)
+        predicate, then_arm, else_arm = node.operands
+        then_on = THEN_ON[node.operator]
+        SitePaths.walk(predicate, fixed).flat_map do |outcomes, value|
+          body = (value == then_on ? then_arm : else_arm)&.body
+          next [[outcomes, nil]] if body.nil?
+
+          SitePaths.walk(body, fixed).map do |more, _|
+            [outcomes.merge(more), nil]
+          end
+        end
+      end
+
+      # Its value in each column: its taken arm's body's, nil for
+      # a plain arm.
+      def value(_operator, operands)
+        _, *arms = operands
+        bodies = arms.map { |arm| arm[:body]&.fetch(:cells) }
+        arms.first[:cells].each_index.map do |column|
+          taken = arms.index { |arm| arm[:cells][column] }
+          taken && bodies[taken]&.fetch(column)
+        end
+      end
+    end
+
+    # A condition whose predicate picks an arm: a ternary, an if
+    # or an unless.
+    module Choice
+      extend Base
+      extend Arms
+
+      OPERATORS = CHOICES
+
+      # What its site's leave call wraps: an if's or an unless's
+      # predicate, a leaf's byte range or a nested Condition, as
+      # its path is decided there and its arms are statements that
+      # may return or raise; a ternary as a whole.
+      def self.trailed(condition)
+        return condition if condition.operator == '?:'
+
+        condition.operands.first
+      end
+
+      # The name of one of its arms, of a condition named choice:
+      # then or else for an if or an unless, as its text is
+      # statements; ? or : for a ternary's, then its condition's
+      # operator, or its text for a plain arm.
+      def self.arm_label(arm, choice)
+        return arm[:arm].to_s if STATEMENT_CHOICES.include?(choice)
+
+        mark = arm[:arm] == :then ? '?' : ':'
+        body = arm[:body]
+        "#{mark} #{body ? body[:operator] : arm[:text]}"
+      end
+    end
+  end
+end

data/lib/path_coverage/kinds/contains.rb

@@ -0,0 +1,111 @@
+require_relative 'base'
+require_relative 'block'
+
+module PathCoverage
+  module Kinds
+    # A leaf with sites inside it, eg ids.select { |i| i.odd? }.any?
+    # as an operand of an &&: its operands are those sites'
+    # Conditions, which run as it does, then the leaf's own byte
+    # range, whose outcome is its value.
+    module Contains
+      extend Base
+
+      OPERATORS = [CONTAINS].freeze
+
+      # The ways node can be evaluated: each way of every one of
+      # the sites inside it, then each way of the leaf itself, its
+      # value the whole's.
+      def self.ways(node, fixed)
+        inner = node.operands[0...-1]
+        before = inner.reduce([{}]) do |ways, site|
+          ways.product(SitePaths.walk(site, fixed))
+              .map { |outcomes, (more, _)| outcomes.merge(more) }
+        end
+        before.flat_map do |outcomes|
+          leaf_ways(node, outcomes, fixed).map do |more, value|
+            [outcomes.merge(more), value]
+          end
+        end
+      end
+
+      # The ways the leaf of node can be evaluated after the sites
+      # inside it took outcomes: the one outcome it must have then,
+      # when known, else true or false.
+      def self.leaf_ways(node, outcomes, fixed)
+        range = node.operands.last
+        known = known_outcome(node, outcomes, fixed)
+        return SitePaths.leaf(range, fixed) if known.nil?
+
+        [[{ range => known }, known]]
+      end
+
+      # The outcome the leaf of node must have after the sites
+      # inside it took outcomes, nil when it can have either: for
+      # a call treated as nonempty, eg any?, whether its receiver
+      # has items; for a leaf that is wholly one site, eg a find,
+      # that site's value. Each only when the site's kind can
+      # tell. A nonempty call has no arguments, so its receiver is
+      # the largest of those sites, any other lying within it.
+      def self.known_outcome(node, outcomes, fixed)
+        *inner, range = node.operands
+        if node.fixed[range] == :nonempty
+          receiver = inner.max_by { |site| site.extent.size }
+          return Block.items?(receiver, outcomes)
+        end
+        whole = inner.find { |site| site.extent == range }
+        whole && value_on(whole, outcomes, fixed)
+      end
+
+      # site's value on its way that took outcomes, one of its
+      # own, nil when its kind cannot tell.
+      def self.value_on(site, outcomes, fixed)
+        ways = SitePaths.walk(site, fixed)
+        ways.find { |more, _| more <= outcomes }.last
+      end
+
+      # Its value in each column: the leaf's own, its last operand.
+      def self.value(_operator, operands)
+        operands.last[:cells]
+      end
+
+      # nodes, labelled and texted so their rows read as the
+      # leaf's code does.
+      # Each site inside the leaf is labelled with the leaf's text
+      # before it, its operator, and its own opening, eg select {
+      # for ids.select { |id| id.odd? }.any?, or ( || for
+      # (a || b).any?.
+      # The leaf is texted with the last site's own closing, then
+      # the leaf's text after that site, eg }.any? or ).any?.
+      def self.texted(source, condition, nodes)
+        *inner, range = condition.operands
+        starts = [range.begin, *inner.map { |site| site.extent.end }]
+        labelled = inner.zip(starts, nodes).map do |site, at, node|
+          node.merge(label: label(source, site, at))
+        end
+        text = tail(source, inner.last, range)
+        [*labelled, nodes.last.merge(text:)]
+      end
+
+      # site's label inside a leaf: the leaf's text from byte at
+      # up to site, then site's operator and its own opening.
+      def self.label(source, site, at)
+        before = source.byteslice(at...site.extent.begin).strip
+        opening, = Kinds.of(site.operator).brackets(source, site)
+        [before, site.operator, opening].reject(&:empty?).join(' ')
+      end
+
+      # The text of the leaf at range: the closing of last, the
+      # last site inside the leaf, then the leaf's text after it.
+      def self.tail(source, last, range)
+        _, closing = Kinds.of(last.operator).brackets(source, last)
+        closing + source.byteslice(last.extent.end...range.end)
+      end
+
+      # The sites inside it, then the leaf, as siblings, so each
+      # site's rows are drawn once, eg select { then }.any?.
+      def self.unfold(node)
+        node[:operands]
+      end
+    end
+  end
+end

data/lib/path_coverage/kinds/safe.rb

@@ -0,0 +1,151 @@
+require_relative 'base'
+
+module PathCoverage
+  module Kinds
+    # A &. chain, eg user&.account&.owner, each receiver nil or
+    # not, a nil one skipping the rest of the chain. As a site of
+    # its own its operands are its receivers; nested in another,
+    # they are its receivers then its value, its last leaf. Each
+    # receiver is wrapped in a present call, which passes it on
+    # unchanged, so it is still evaluated just once.
+    module Safe
+      extend Base
+
+      OPERATORS = [SAFE].freeze
+
+      # The ways node, nested in a condition, can be evaluated,
+      # its value its last leaf.
+      def self.ways(node, fixed)
+        chain(node.operands[0...-1], node.operands.last, fixed)
+      end
+
+      # The ways a &. chain site can be evaluated, every operand
+      # a receiver.
+      def self.root_ways(node, fixed)
+        chain(node.operands, nil, fixed)
+      end
+
+      # The ways a &. chain can be evaluated: each receiver not
+      # nil going on to the next, a nil one ending the chain, its
+      # value false; then, given a last leaf, the chain's value
+      # as an operand of a condition, the ways it can be.
+      def self.chain(receivers, last, fixed)
+        first, *rest = receivers
+        on = if !rest.empty? then chain(rest, last, fixed)
+             elsif last then SitePaths.walk(last, fixed)
+             else [[{}, true]]
+             end
+        present = on.map do |outcomes, value|
+          [outcomes.merge(first => PRESENCE[0]), value]
+        end
+        return present if fixed[first] == :present
+
+        [*present, [{ first => PRESENCE[1] }, false]]
+      end
+
+      # Its value in each column: false where a receiver was nil,
+      # as the chain then gives nil, else its last leaf's.
+      def self.value(_operator, operands)
+        leaves = operands.reject { |operand| operand[:called] }
+        columns = leaves.map { |operand| operand[:cells] }.transpose
+        columns.map do |column|
+          column.include?(PRESENCE[1]) ? false : column.last
+        end
+      end
+
+      # The inserts for a &. chain site: each receiver in a present
+      # call, and the whole chain in a leave call that enters it
+      # first. Eg user&.account becomes, in effect,
+      # leave(enter(site, 1), present(site, 0, 0, user)&.account).
+      def self.site_inserts(site, condition)
+        leaves = condition.leaves
+        enter = "PathCoverage.enter(#{site.inspect}, #{leaves.size})"
+        call = "PathCoverage.leave(#{enter}, "
+        command = condition.commands.include?(condition.extent)
+        presents = leaves.each_with_index.flat_map do |range, index|
+          Rewriter.wrap(present(site, index, 0), range, false, :leaf)
+        end
+        extent = condition.extent
+        presents + Rewriter.wrap(call, extent, command, :site)
+      end
+
+      # Its leaves need present and chained calls.
+      def self.own_calls?
+        true
+      end
+
+      # { leaf range => the opening of its call } for the leaves of
+      # chain nested in a site whose leaves are leaves: a
+      # receiver's present call, and the chain's value's chained
+      # call, each told where its chain's leaves start.
+      def self.calls(site, chain, leaves)
+        first = leaves.index(chain.operands.first)
+        *receivers, value = chain.operands
+        calls = receivers.to_h do |range|
+          [range, present(site, leaves.index(range), first)]
+        end
+        at = leaves.index(value)
+        calls.merge(value => chained(site, at, first))
+      end
+
+      # The opening of the chained call around the index-th leaf
+      # of site, a chain's value, its chain's leaves starting at
+      # first.
+      def self.chained(site, index, first)
+        "PathCoverage.chained(#{site.inspect}, #{index}, #{first}, "
+      end
+
+      # The opening of the present call around the index-th leaf
+      # of site, its chain's leaves starting at first.
+      def self.present(site, index, first)
+        "PathCoverage.present(#{site.inspect}, #{index}, #{first}, "
+      end
+
+      # Its leaves' nodes, each after the first showing only what
+      # it adds to the one before, eg account after user.
+      # A leading &. is left out, as the chain's own row shows it.
+      # Any of the chain after its last leaf follows, eg owner in
+      # user&.account&.owner, as a node of its own.
+      def self.texted(source, condition, nodes)
+        ranges = condition.operands
+        texted = with_added(source, ranges, nodes)
+        rest = shown(source, ranges.last.end...condition.extent.end)
+        rest.empty? ? texted : [*texted, called(rest, texted.last)]
+      end
+
+      # nodes, the nodes of a chain's leaves at ranges, each after
+      # the first showing only what it adds to the one before.
+      def self.with_added(source, ranges, nodes)
+        nodes.each_with_index.map do |node, index|
+          next node if index.zero?
+
+          added = ranges[index - 1].end...ranges[index].end
+          node.merge(text: shown(source, added))
+        end
+      end
+
+      # The text of source at range, less any leading &.
+      def self.shown(source, range)
+        source.byteslice(range).delete_prefix('&.')
+      end
+
+      # The node of text, the end of a chain after its last
+      # leaf, eg owner: no leaf, as it decides no path, but marked
+      # called on each path where last, the last leaf, was not
+      # nil.
+      def self.called(text, last)
+        cells = last[:cells].map { |cell| cell == PRESENCE[0] }
+        { text:, called: true, cells: }
+      end
+
+      # The rows of its leaves, each under the one before, as each
+      # is reached only when the one before is not nil.
+      def self.rows(chain, indent)
+        chain[:operands].each_with_index.map do |operand, depth|
+          branch = "#{indent}#{'   ' * depth}└─ "
+          HtmlTree.operand_row(operand, branch)
+        end
+      end
+    end
+  end
+end

data/lib/path_coverage/kinds/write.rb

@@ -0,0 +1,54 @@
+require_relative 'base'
+require_relative 'choice'
+
+module PathCoverage
+  module Kinds
+    # A ||= or &&= write, which decides whether its right side
+    # runs as an unless or an if decides its arm: its target is
+    # its predicate, its right side its then arm, so its ways and
+    # value are a choice's. Its target is never wrapped, so never
+    # read again.
+    module Write
+      extend Base
+      extend Arms
+
+      OPERATORS = WRITES
+
+      # The name of its arm, of a write named choice: the operator
+      # and its right side, eg ||= key.upcase.
+      def self.arm_label(arm, choice)
+        "#{choice} #{arm[:text]}"
+      end
+
+      # Its target needs no record call, and its right side a
+      # written_at call.
+      def self.own_calls?
+        true
+      end
+
+      # { target range => nil }: its target is never read, so
+      # never wrapped.
+      def self.calls(_site, inner, _leaves)
+        { inner.operands.first => nil }
+      end
+
+      # A write, its target the site's at-th leaf: its right side
+      # in a written_at call, which notes the target's outcome when
+      # it runs, and the whole of it in a settle call, which notes
+      # the other when it does not. A right side among commands,
+      # eg a command call, is parenthesised. Eg x ||= v becomes,
+      # in effect, settle(site, at, true, x ||= written_at(site,
+      # at, false, v)).
+      def self.inserts(site, inner, at, commands)
+        _target, arm = inner.operands
+        ran = THEN_ON[inner.operator]
+        name = site.inspect
+        written = "PathCoverage.written_at(#{name}, #{at}, #{ran}, "
+        settle = "PathCoverage.settle(#{name}, #{at}, #{!ran}, "
+        command = commands.include?(arm.extent)
+        Rewriter.wrap(settle, inner.extent, false, :kind) +
+          Rewriter.wrap(written, arm.extent, command, :leaf)
+      end
+    end
+  end
+end

data/lib/path_coverage/kinds.rb

@@ -0,0 +1,37 @@
+require_relative 'condition'
+require_relative 'kinds/block'
+require_relative 'kinds/case'
+require_relative 'kinds/chain'
+require_relative 'kinds/choice'
+require_relative 'kinds/contains'
+require_relative 'kinds/safe'
+require_relative 'kinds/write'
+
+module PathCoverage
+  # The kinds of condition, each a module that knows, for a
+  # condition named by one of its OPERATORS, the ways it can be
+  # evaluated, its value in each column of its site's tree, and
+  # the inserts that instrument it. Each extends Kinds::Base,
+  # whose hooks give what most kinds need.
+  module Kinds
+    # Every kind, each named by its operators.
+    ALL = [Block, Case, Chain, Choice, Contains, Safe, Write].freeze
+
+    # { operator => kind } for every operator of every kind.
+    BY_OPERATOR = ALL.flat_map do |kind|
+      kind::OPERATORS.map { |operator| [operator, kind] }
+    end.to_h.freeze
+
+    # The kind of a condition named operator, eg Chain for &&.
+    def self.of(operator)
+      BY_OPERATOR.fetch(operator)
+    end
+
+    # The names of the kinds measured, eg chain for Chain: a
+    # report's fingerprint, as runs measuring different kinds
+    # list a site's paths differently.
+    def self.names
+      ALL.map { |kind| kind.name.split('::').last.downcase }
+    end
+  end
+end