path_coverage 0.0.1 → 0.1.0

data/lib/path_coverage/site_tree.rb

@@ -0,0 +1,134 @@
+require_relative 'condition'
+
+module PathCoverage
+  # The tree shown under a site's line on its file's page: a
+  # grid whose columns are the site's paths, never taken first.
+  module SiteTree
+    # { operator:, counts:, cells:, operands: } for one site,
+    # from its paths, [{path:, count:}, ...]. counts are the
+    # columns' counts. Every node has cells, one per column: a
+    # leaf { text:, cells: } its outcome, nil where unreached;
+    # a condition { operator:, cells:, operands: } its value;
+    # an arm { arm:, text:, cells:, body: } whether the column
+    # took it, body being its condition's tree, nil for a plain
+    # arm. Texts are cut from source at the manifest's ranges.
+    def self.of(source, condition, paths)
+      columns = paths.sort_by.with_index do |taken, i|
+        [taken[:count].zero? ? 0 : 1, i]
+      end
+      outcomes = columns.map { |taken| taken[:path] }
+      tree = node(source, condition, outcomes, (0..).each)
+      tree.merge(counts: columns.map { |taken| taken[:count] })
+    end
+
+    # 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)
+      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
+    end
+
+    # condition's node from its operands' nodes, its ternary
+    # arms built in order after its predicate, as each arm's
+    # cells follow from the predicate's.
+    def self.arms(source, condition, operands, outcomes, leaves)
+      predicate = operands.first
+      operands = operands.map do |operand|
+        next operand unless operand.is_a?(Arm)
+
+        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
+
+    # 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)
+      {
+        arm: arm.kind, text: text_of(source, arm),
+        cells: decided.map { |outcome| outcome == picked }, body:
+      }
+    end
+
+    # A condition's value in each column: a ternary's or an
+    # if's is its taken arm's body's, nil for a plain arm; a
+    # chain's is that of the last operand it reached.
+    def self.value(operator, operands)
+      if CHOICES.include?(operator)
+        _, *arms = operands
+        arms.map { |arm| arm[:body]&.fetch(:cells) }
+            .then { |bodies| ternary_value(arms, bodies) }
+      else
+        operands.map { |operand| operand[:cells] }
+                .transpose.map { |column| column.compact.last }
+      end
+    end
+
+    # Each column's value from the arm it took.
+    def self.ternary_value(arms, bodies)
+      arms.first[:cells].each_index.map do |column|
+        taken = arms.index { |arm| arm[:cells][column] }
+        taken && bodies[taken]&.fetch(column)
+      end
+    end
+
+    # One leaf's text and its outcome in each column.
+    def self.leaf(source, range, outcomes, index)
+      {
+        text: source.byteslice(range),
+        cells: outcomes.map { |path| path[index] }
+      }
+    end
+  end
+end

data/lib/path_coverage/source_lines.rb

@@ -0,0 +1,79 @@
+require_relative 'gaps'
+
+module PathCoverage
+  # The lines of one file's page, each with the status of the
+  # conditions on it.
+  module SourceLines
+    # [{number:, text:, status:, span:}] for each line of
+    # source. A line in a site's span shares one button with
+    # the span's other lines; status and span are nil on a line
+    # with no condition.
+    def self.of(source, sites, operands)
+      marks = marks(source, sites, operands)
+      source.lines.each_with_index.map do |text, index|
+        number = index + 1
+        mark = marks.fetch(number, {})
+        {
+          number:, text: text.chomp,
+          status: mark[:status], span: mark[:span]
+        }
+      end
+    end
+
+    # { line number => {status:, span:} } for each line a site
+    # covers, every line of a merged span sharing that span.
+    def self.marks(source, sites, operands)
+      blocks = merged(spans_of(source, sites, operands))
+      blocks.each_with_object({}) do |(span, status), marks|
+        span.each { |number| marks[number] = { status:, span: } }
+      end
+    end
+
+    # [span, status] for each site: from the line it starts on
+    # to the line its last operand ends on.
+    def self.spans_of(source, sites, operands)
+      sites.map do |site, condition|
+        last = condition.leaves.last
+        span = line_of(site)..end_line(source, last)
+        [span, status_of(operands.fetch(site))]
+      end
+    end
+
+    # The spans merged wherever they overlap, in line order. A
+    # merged span has :gaps if any of its sites has, so a
+    # covered site never hides another's gaps.
+    def self.merged(spans)
+      sorted = spans.sort_by { |span, _| span.begin }
+      sorted.each_with_object([]) do |(span, status), blocks|
+        last_span, last_status = blocks.last
+        if last_span && last_span.end >= span.begin
+          joined = last_span.begin..[last_span.end, span.end].max
+          blocks[-1] = [joined, worse(last_status, status)]
+        else
+          blocks << [span, status]
+        end
+      end
+    end
+
+    # :gaps if either status is :gaps, else :covered.
+    def self.worse(one, other)
+      [one, other].include?(:gaps) ? :gaps : :covered
+    end
+
+    # :covered when no operand has a gap, else :gaps.
+    def self.status_of(counts)
+      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.
+    def self.line_of(site)
+      site[/:(\d+):\d+\z/, 1].to_i
+    end
+
+    # The line of source on which byte range ends.
+    def self.end_line(source, range)
+      source.byteslice(0, range.end).count("\n") + 1
+    end
+  end
+end

data/lib/path_coverage/summary.rb

@@ -0,0 +1,52 @@
+require_relative 'totals'
+
+module PathCoverage
+  # 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 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 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] }
+      {
+        sites: rows.sum { |row| row[:sites] },
+        decisions: add(rows.map { |row| row[:decisions] }),
+        methods: methods.first && add(methods)
+      }
+    end
+
+    # [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.
+    def self.path_of(site)
+      site.sub(/:\d+:\d+\z/, '')
+    end
+  end
+end

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

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

data/lib/path_coverage.rb

@@ -1,5 +1,2 @@
-# A placeholder holding the gem name path_coverage for the
-# successor of condition_coverage; it does nothing yet.
-module PathCoverage
-  VERSION = '0.0.1'.freeze
-end
+require_relative 'path_coverage/version'
+require_relative 'path_coverage/kernel'

metadata

@@ -1,29 +1,88 @@
 --- !ruby/object:Gem::Specification
 name: path_coverage
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Jon Jagger
-autorequire: 
-bindir: bin
+autorequire:
+bindir: exe
 cert_chain: []
-date: 2026-11-02 00:00:00.000000000 Z
-dependencies: []
-description: Reserves the name for the successor of condition_coverage, which records
-  the paths taken through each condition and method.
-email: 
-executables: []
+date: 2026-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Records which paths each condition and each method took, and reports
+  the paths never taken in the terminal and as HTML.
+email:
+executables:
+- path_coverage_collector
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.md
+- README.md
+- exe/path_coverage_collector
 - lib/path_coverage.rb
-homepage: https://github.com/cyber-dojo/condition_coverage
+- 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
+- lib/path_coverage/gaps.rb
+- lib/path_coverage/html/file.html
+- lib/path_coverage/html/index.html
+- lib/path_coverage/html/side.js
+- lib/path_coverage/html/sort.js
+- lib/path_coverage/html/style.css
+- lib/path_coverage/html/toggle.js
+- lib/path_coverage/html_file.rb
+- lib/path_coverage/html_index.rb
+- lib/path_coverage/html_nav.rb
+- lib/path_coverage/html_paths.rb
+- lib/path_coverage/html_report.rb
+- lib/path_coverage/html_template.rb
+- lib/path_coverage/html_tree.rb
+- 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
+- lib/path_coverage/path_manifest.rb
+- lib/path_coverage/paths_report.rb
+- lib/path_coverage/post.rb
+- lib/path_coverage/recorder.rb
+- lib/path_coverage/render.rb
+- lib/path_coverage/result.rb
+- lib/path_coverage/rewriter.rb
+- lib/path_coverage/site.rb
+- lib/path_coverage/site_paths.rb
+- 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:
 - BSD-2-Clause
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -38,8 +97,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: Path coverage for Ruby, alongside SimpleCov
+summary: Path coverage for Ruby, alongside SimpleCov branch coverage
 test_files: []