path_coverage 0.1.0 → 0.2.0

data/lib/path_coverage/site_paths.rb

@@ -1,78 +1,29 @@
 require_relative 'condition'
+require_relative 'kinds'
 
 module PathCoverage
   # The paths an evaluation of a site can take, worked out
   # from its condition alone: the outcome of each leaf, in leaf
   # order, nil for a leaf that evaluation never reaches.
   module SitePaths
-    # Every possible path through site's condition, true
-    # before false; a stop-early block method's are fixed by its
-    # shape alone.
+    # Every possible path through site's condition, true before
+    # false, as its kind gives the ways a site of it can be
+    # evaluated.
     def self.possible(site)
-      shape = BLOCK_PATHS[site.operator]
-      return shape if shape
-
-      walk(site, site.fixed).map do |outcomes, _value|
+      ways = Kinds.of(site.operator).root_ways(site, site.fixed)
+      ways.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. 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
-
     # [[{ 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 }. A case is the chain of its whens' conditions.
+    # a whole, as its kind gives them; fixed is the site's
+    # { leaf range => its one outcome }.
     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
 
-    # The ways a chain of one operator 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.chain(node, fixed)
-      first, *rest = node.operands
-      goes_on = CONTINUES_ON.fetch(node.operator)
-      rest.reduce(walk(first, fixed)) do |ways, operand|
-        ways.flat_map do |outcomes, value|
-          next [[outcomes, value]] unless value == goes_on
-
-          walk(operand, fixed).map do |more, after|
-            [outcomes.merge(more), after]
-          end
-        end
-      end
-    end
-
-    # 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_on ? then_arm : else_arm)&.body
-        next [[outcomes, nil]] if body.nil?
-
-        walk(body, fixed).map do |more, _|
-          [outcomes.merge(more), nil]
-        end
-      end
+      Kinds.of(node.operator).ways(node, fixed)
     end
 
     # The ways a leaf can be evaluated: true, then false, or

data/lib/path_coverage/site_tree.rb

@@ -1,4 +1,5 @@
 require_relative 'condition'
+require_relative 'kinds'
 
 module PathCoverage
   # The tree shown under a site's line on its file's page: a
@@ -21,27 +22,25 @@ module PathCoverage
       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.
+    # The tree of condition, as its kind builds it, 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)
+      kind = Kinds.of(condition.operator)
+      kind.node(source, condition, 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|
+      nodes = 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
+      Kinds.of(condition.operator).texted(source, condition, nodes)
     end
 
     # condition's node from its operands' nodes, its ternary
@@ -55,36 +54,14 @@ module PathCoverage
         decided = [predicate[:cells], THEN_ON[condition.operator]]
         arm(source, operand, decided, outcomes, leaves)
       end
-      cells = value(condition.operator, operands)
+      operator = condition.operator
+      cells = Kinds.of(operator).value(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
+      arm.extent ? source.byteslice(arm.extent) : nil
     end
 
     # One arm of a ternary, an if or an unless: its text, nil
@@ -94,35 +71,13 @@ module PathCoverage
     # 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)
+      body = arm.body ? node(source, arm.body, outcomes, leaves) : nil
       {
         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)
       {

data/lib/path_coverage/summary.rb

@@ -1,3 +1,4 @@
+require_relative 'configuration'
 require_relative 'totals'
 
 module PathCoverage
@@ -16,7 +17,7 @@ module PathCoverage
         {
           path:, sites: sites.size,
           decisions: Totals.decisions(sites.to_h),
-          methods: paths && methods_of(path, methods, paths)
+          methods: paths ? methods_of(path, methods, paths) : nil
         }
       end
     end
@@ -35,13 +36,40 @@ module PathCoverage
       {
         sites: rows.sum { |row| row[:sites] },
         decisions: add(rows.map { |row| row[:decisions] }),
-        methods: methods.first && add(methods)
+        methods: methods.first ? add(methods) : nil
       }
     end
 
-    # [taken, possible] pairs added together.
+    # [name, rows, total] for each of groups, { name => [glob,
+    # ...] }, in order: the rows whose path matches any of its
+    # globs, and their total. Then Ungrouped, the rows no group
+    # matches, when there are any.
+    def self.groups(rows, groups)
+      grouped = groups.map do |name, globs|
+        own = rows.select { |row| matches?(row[:path], globs) }
+        [name, own, total(own)]
+      end
+      every = groups.values.flatten
+      rest = rows.reject { |row| matches?(row[:path], every) }
+      return grouped if rest.empty?
+
+      grouped << ['Ungrouped', rest, total(rest)]
+    end
+
+    # True when path matches any of globs.
+    def self.matches?(path, globs)
+      globs.any? do |glob|
+        File.fnmatch?(glob, path, Configuration::GLOB_FLAGS)
+      end
+    end
+
+    # [taken, possible] pairs added together, eg [[1, 3], [2, 4]]
+    # gives [3, 7]; no pairs, as for a group no file is in, gives
+    # [0, 0].
     def self.add(pairs)
-      pairs.transpose.map(&:sum)
+      pairs.reduce([0, 0]) do |(taken, possible), (more, of)|
+        [taken + more, possible + of]
+      end
     end
 
     # The file a site is in: its name minus :line:column.

data/lib/path_coverage/totals.rb

@@ -13,7 +13,7 @@ module PathCoverage
       [every.count { |each| each[:count].positive? }, every.size]
     end
 
-    # Paths across each method's decisions: methods, as
+    # Paths within each method, through its decisions: methods, as
     # PathManifest.methods gives them, each with every path
     # through its decisions; paths, as the recorder counts
     # them, holds the ones taken.

data/lib/path_coverage/version.rb

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

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: path_coverage
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jon Jagger
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
 date: 2026-11-03 00:00:00.000000000 Z
@@ -26,7 +26,7 @@ dependencies:
         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:
+email: 
 executables:
 - path_coverage_collector
 extensions: []
@@ -41,35 +41,59 @@ files:
 - lib/path_coverage/collector.rb
 - lib/path_coverage/condition.rb
 - lib/path_coverage/configuration.rb
+- lib/path_coverage/configuration_paths.rb
+- lib/path_coverage/console_summary.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/tabs.js
 - lib/path_coverage/html/toggle.js
 - lib/path_coverage/html_file.rb
 - lib/path_coverage/html_index.rb
+- lib/path_coverage/html_index_head.rb
 - lib/path_coverage/html_nav.rb
 - lib/path_coverage/html_paths.rb
 - lib/path_coverage/html_report.rb
+- lib/path_coverage/html_tabs.rb
 - lib/path_coverage/html_template.rb
 - lib/path_coverage/html_tree.rb
+- lib/path_coverage/json_reader.rb
 - lib/path_coverage/json_writer.rb
 - lib/path_coverage/kernel.rb
+- lib/path_coverage/kinds.rb
+- lib/path_coverage/kinds/base.rb
+- lib/path_coverage/kinds/block.rb
+- lib/path_coverage/kinds/case.rb
+- lib/path_coverage/kinds/chain.rb
+- lib/path_coverage/kinds/choice.rb
+- lib/path_coverage/kinds/contains.rb
+- lib/path_coverage/kinds/safe.rb
+- lib/path_coverage/kinds/write.rb
 - lib/path_coverage/manifest.rb
 - lib/path_coverage/manifest_blocks.rb
 - lib/path_coverage/manifest_case.rb
+- lib/path_coverage/manifest_chains.rb
 - lib/path_coverage/manifest_choices.rb
+- lib/path_coverage/manifest_folding.rb
+- lib/path_coverage/manifest_ignoring.rb
+- lib/path_coverage/manifest_writes.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/recorder_blocks.rb
+- lib/path_coverage/recorder_cases.rb
+- lib/path_coverage/recorder_chains.rb
+- lib/path_coverage/recorder_writes.rb
 - lib/path_coverage/render.rb
 - lib/path_coverage/result.rb
 - lib/path_coverage/rewriter.rb
+- lib/path_coverage/rewriter_nested.rb
 - lib/path_coverage/site.rb
 - lib/path_coverage/site_paths.rb
 - lib/path_coverage/site_tree.rb
@@ -82,7 +106,7 @@ licenses:
 - BSD-2-Clause
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -97,8 +121,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Path coverage for Ruby, alongside SimpleCov branch coverage
 test_files: []