path_coverage 0.0.2 → 0.1.0

data/lib/path_coverage/rewriter.rb

@@ -1,3 +1,5 @@
+require_relative 'condition'
+
 module PathCoverage
   # Instruments source text so that each leaf operand records its
   # outcome when the code runs. It inserts text at the byte
@@ -13,12 +15,54 @@ module PathCoverage
     # line numbers still match the file on disk.
     def self.rewrite(source, sites, methods = {})
       inserts = sites.flat_map do |site, condition|
-        record_inserts(site, condition) +
-          trail_inserts(site, condition)
+        site_inserts(site, condition)
       end
       apply(source.dup, inserts + path_inserts(methods))
     end
 
+    # The inserts for one site, by its kind: a case's patterns'
+    # stand-ins, a block method's call and block, or any other
+    # site's leaves' records and its leave.
+    def self.site_inserts(site, condition)
+      kind = condition.operator
+      return case_inserts(site, condition) if kind == 'case'
+
+      blocks = BLOCK_PATHS.key?(kind)
+      return block_inserts(site, condition) if blocks
+
+      record_inserts(site, condition) + trail_inserts(site, condition)
+    end
+
+    # The inserts that wrap a block method's call whole in a
+    # leave_items call that enters it first, inside any leave of
+    # a site it is the predicate of, and its block's expression,
+    # outside any site's leave there, in an item call, noting its
+    # last answer, or for a method that calls it with every item
+    # an answer call, noting every answer.
+    def self.block_inserts(site, condition)
+      _receiver, body = condition.leaves
+      enter = "PathCoverage.enter_items(#{site.inspect})"
+      call = "PathCoverage.leave_items(#{enter}, "
+      every = EVERY_ITEM.include?(condition.operator)
+      noter = every ? 'answer' : 'item'
+      item = "PathCoverage.#{noter}(#{site.inspect}, "
+      command = condition.commands.include?(body)
+      wrap(call, condition.extent, false, 0.5) +
+        wrap(item, body, command, 1.5)
+    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.
+    def self.case_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}, "
+        wrap(call, range, false, 0)
+      end
+    end
+
     # The inserts that wrap each of site's leaves in a record
     # call, innermost of all.
     def self.record_inserts(site, condition)
@@ -45,12 +89,14 @@ module PathCoverage
       wrap(call, nested ? wrapped.extent : wrapped, word, 1)
     end
 
-    # What a site's leave call wraps: an if'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; any other site as a whole.
+    # What a 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; any other site as a whole.
     def self.trailed(condition)
-      return condition unless condition.operator == 'if'
+      unless STATEMENT_CHOICES.include?(condition.operator)
+        return condition
+      end
 
       condition.operands.first
     end

data/lib/path_coverage/site.rb

@@ -4,7 +4,12 @@ module PathCoverage
   module Site
     # "path:line:column" of node, eg "k.rb:2:2".
     def self.of(path, node)
-      loc = node.location
+      at(path, node.location)
+    end
+
+    # "path:line:column" of where loc starts, eg an if's keyword,
+    # which a modifier if's statement comes before.
+    def self.at(path, loc)
       "#{path}:#{loc.start_line}:#{loc.start_column}"
     end
   end

data/lib/path_coverage/site_paths.rb

@@ -6,27 +6,38 @@ module PathCoverage
   # order, nil for a leaf that evaluation never reaches.
   module SitePaths
     # Every possible path through site's condition, true
-    # before false.
+    # before false; a stop-early block method's are fixed by its
+    # shape alone.
     def self.possible(site)
+      shape = BLOCK_PATHS[site.operator]
+      return shape if shape
+
       walk(site, site.fixed).map do |outcomes, _value|
         site.leaves.map { |range| outcomes[range] }
       end
     end
 
     # The outcome of an operand on which each operator goes on
-    # to its next operand; any other ends the chain there.
+    # 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
+      '&&' => true, 'and' => true, '||' => false, 'or' => false,
+      'when' => false, 'case' => false
     }.freeze
 
     # [[{ leaf range => outcome }, value], ...] for each way
     # node can be evaluated, value being the outcome of node as
     # a whole; fixed is the site's { leaf range => its one
-    # outcome }.
+    # outcome }. A case is the chain of its whens' conditions.
     def self.walk(node, fixed)
       return leaf(node, fixed) unless node.is_a?(Condition)
       return ternary(node, fixed) if CHOICES.include?(node.operator)
 
+      if node.operator == 'case'
+        whens = node.operands.filter_map(&:body)
+        return chain(node.with(operands: whens), fixed)
+      end
+
       chain(node, fixed)
     end
 
@@ -47,14 +58,15 @@ module PathCoverage
       end
     end
 
-    # The ways a ternary or an if can be evaluated: each way of
-    # its predicate, then each way of the condition the arm it
-    # picks is, if that arm is one; an if with no else arm
-    # picks none. Its value is that of no choice, so is nil.
+    # The ways a ternary, an if or an unless 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 self.ternary(node, fixed)
       predicate, then_arm, else_arm = node.operands
+      then_on = THEN_ON[node.operator]
       walk(predicate, fixed).flat_map do |outcomes, value|
-        body = (value ? then_arm : else_arm)&.body
+        body = (value == then_on ? then_arm : else_arm)&.body
         next [[outcomes, nil]] if body.nil?
 
         walk(body, fixed).map do |more, _|

data/lib/path_coverage/site_tree.rb

@@ -24,14 +24,24 @@ module PathCoverage
     # The tree of condition, each leaf taking the next index of
     # leaves, so leaves pair with path entries left to right.
     def self.node(source, condition, outcomes, leaves)
-      operands = condition.operands.map do |operand|
+      if condition.operator == 'case'
+        return case_arms(source, condition.operands, outcomes, leaves)
+      end
+
+      operands = operands_of(source, condition, outcomes, leaves)
+      arms(source, condition, operands, outcomes, leaves)
+    end
+
+    # condition's operands' nodes, leaves and nested conditions
+    # built in order, its arms left for arms to build after.
+    def self.operands_of(source, condition, outcomes, leaves)
+      condition.operands.map do |operand|
         case operand
         when Condition then node(source, operand, outcomes, leaves)
         when Arm then operand
         else leaf(source, operand, outcomes, leaves.next)
         end
       end
-      arms(source, condition, operands, outcomes, leaves)
     end
 
     # condition's node from its operands' nodes, its ternary
@@ -42,21 +52,51 @@ module PathCoverage
       operands = operands.map do |operand|
         next operand unless operand.is_a?(Arm)
 
-        arm(source, operand, predicate[:cells], outcomes, leaves)
+        decided = [predicate[:cells], THEN_ON[condition.operator]]
+        arm(source, operand, decided, outcomes, leaves)
       end
       cells = value(condition.operator, operands)
       { operator: condition.operator, cells:, operands: }
     end
 
-    # One arm of a ternary or an if: its text, nil for an arm
-    # with no statements, whether each column took it, from the
-    # predicate's cells, and the tree of its condition.
-    def self.arm(source, arm, decided, outcomes, leaves)
-      picked = arm.kind == :then
+    # A case's node 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.case_arms(source, arms, outcomes, leaves)
+      matched = []
+      operands = arms.map do |arm|
+        body = arm.body && node(source, arm.body, outcomes, leaves)
+        matched << body[:cells].map { |cell| cell == true } if body
+        cells = body ? matched.last : unmatched(matched, outcomes)
+        { arm: arm.kind, text: text_of(source, arm), cells:, body: }
+      end
+      { operator: 'case', cells: Array.new(outcomes.size), operands: }
+    end
+
+    # An arm's text, nil for one with no statements.
+    def self.text_of(source, arm)
+      arm.extent && source.byteslice(arm.extent)
+    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
+
+    # One arm of a ternary, an if or an unless: its text, nil
+    # for an arm with no statements, whether each column took
+    # it, from the predicate's cells and the outcome on which
+    # its choice takes its then arm, and the tree of its
+    # condition.
+    def self.arm(source, arm, (decided, then_on), outcomes, leaves)
+      picked = arm.kind == :then ? then_on : !then_on
       body = arm.body && node(source, arm.body, outcomes, leaves)
-      text = arm.extent && source.byteslice(arm.extent)
       {
-        arm: arm.kind, text:,
+        arm: arm.kind, text: text_of(source, arm),
         cells: decided.map { |outcome| outcome == picked }, body:
       }
     end

data/lib/path_coverage/summary.rb

@@ -1,28 +1,47 @@
+require_relative 'totals'
+
 module PathCoverage
-  # The per-file numbers the HTML index page shows.
+  # The per-file numbers the HTML index page shows, and their
+  # total over every file.
   module Summary
-    # One row per file that has sites in operands, as
-    # Result#operands gives them, in path order.
-    def self.files(operands)
-      by_path = operands.group_by { |site, _| path_of(site) }
-      by_path.sort.map { |path, sites| row(path, sites) }
+    # One row per file that has sites in site_paths, as
+    # Result#paths gives them, in path order: its sites, and
+    # its decisions total. Its methods total is nil unless
+    # methods, as PathManifest.methods gives them, and paths, as
+    # the recorder counts them, are given, as they are when
+    # methods are measured.
+    def self.files(site_paths, methods = {}, paths = nil)
+      by_path = site_paths.group_by { |site, _| path_of(site) }
+      by_path.sort.map do |path, sites|
+        {
+          path:, sites: sites.size,
+          decisions: Totals.decisions(sites.to_h),
+          methods: paths && methods_of(path, methods, paths)
+        }
+      end
+    end
+
+    # The methods total of the file at path; [0, 0] for a file
+    # with no method of two or more decisions.
+    def self.methods_of(path, methods, paths)
+      own = methods.select { |site, _| path_of(site) == path }
+      Totals.methods(own, paths)
     end
 
-    # The summary row of one file's sites.
-    def self.row(path, sites)
-      operands = sites.flat_map { |_, counts| counts }
-      outcomes = operands.sum { |counts| counts[:only] ? 1 : 2 }
-      seen = operands.sum { |counts| seen_in(counts) }
+    # The sum of each column over rows, a methods total being
+    # nil when the rows' are.
+    def self.total(rows)
+      methods = rows.map { |row| row[:methods] }
       {
-        path:, sites: sites.size, seen:, outcomes:,
-        percent: (100.0 * seen / outcomes).round,
-        missing: outcomes - seen
+        sites: rows.sum { |row| row[:sites] },
+        decisions: add(rows.map { |row| row[:decisions] }),
+        methods: methods.first && add(methods)
       }
     end
 
-    # How many of an operand's two outcomes were seen.
-    def self.seen_in(counts)
-      [counts[:truthy], counts[:falsy]].count(&:positive?)
+    # [taken, possible] pairs added together.
+    def self.add(pairs)
+      pairs.transpose.map(&:sum)
     end
 
     # The file a site is in: its name minus :line:column.

data/lib/path_coverage/totals.rb

@@ -0,0 +1,29 @@
+require_relative 'path_gaps'
+
+module PathCoverage
+  # The two coverage totals, each [taken, possible] paths over
+  # every covered file. They count the very paths the gap
+  # lines list as never taken.
+  module Totals
+    # Paths within each decision: site_paths, as Result#paths
+    # gives them, lists every possible path of each site with
+    # its count; one with a count above zero was taken.
+    def self.decisions(site_paths)
+      every = site_paths.values.flatten
+      [every.count { |each| each[:count].positive? }, every.size]
+    end
+
+    # Paths across each method's decisions: methods, as
+    # PathManifest.methods gives them, each with every path
+    # through its decisions; paths, as the recorder counts
+    # them, holds the ones taken.
+    def self.methods(methods, paths)
+      methods.reduce([0, 0]) do |(taken, possible), (site, method)|
+        every = PathGaps.possible(method.decisions)
+        seen = paths.fetch(site, {})
+        [taken + every.count { |path| seen.key?(path) },
+         possible + every.size]
+      end
+    end
+  end
+end

data/lib/path_coverage/version.rb

@@ -1,3 +1,3 @@
 module PathCoverage
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.1.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: path_coverage
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Jon Jagger
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-02 00:00:00.000000000 Z
+date: 2026-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -37,6 +37,7 @@ files:
 - exe/path_coverage_collector
 - lib/path_coverage.rb
 - lib/path_coverage/auto.rb
+- lib/path_coverage/calls.rb
 - lib/path_coverage/collector.rb
 - lib/path_coverage/condition.rb
 - lib/path_coverage/configuration.rb
@@ -57,6 +58,8 @@ files:
 - lib/path_coverage/json_writer.rb
 - lib/path_coverage/kernel.rb
 - lib/path_coverage/manifest.rb
+- lib/path_coverage/manifest_blocks.rb
+- lib/path_coverage/manifest_case.rb
 - lib/path_coverage/manifest_choices.rb
 - lib/path_coverage/merge.rb
 - lib/path_coverage/path_gaps.rb
@@ -72,6 +75,7 @@ files:
 - lib/path_coverage/site_tree.rb
 - lib/path_coverage/source_lines.rb
 - lib/path_coverage/summary.rb
+- lib/path_coverage/totals.rb
 - lib/path_coverage/version.rb
 homepage: https://github.com/cyber-dojo/path_coverage
 licenses: