path_coverage 0.1.0 → 0.2.0

data/lib/path_coverage/manifest.rb

@@ -2,7 +2,11 @@ require 'prism'
 require_relative 'condition'
 require_relative 'manifest_blocks'
 require_relative 'manifest_case'
+require_relative 'manifest_chains'
 require_relative 'manifest_choices'
+require_relative 'manifest_folding'
+require_relative 'manifest_ignoring'
+require_relative 'manifest_writes'
 require_relative 'site'
 
 module PathCoverage
@@ -10,9 +14,15 @@ module PathCoverage
   # outermost &&, ||, and or or, each ternary, if, unless and case
   # with a subject, with the conditions nested in it.
   module Manifest
-    # { site => Condition } for each site in source.
-    def self.sites(source, path)
-      collector = ConditionSites.new(path)
+    # { site => Condition } for each site in source, none of
+    # them named by an operator in ignored; a call to a method
+    # named in present, as a &.'s receiver, is never nil, and a
+    # call to one named in nonempty, eg any?, is true exactly
+    # when its receiver has items.
+    def self.sites(source, path, ignored = [], present = [],
+                   nonempty = [])
+      collector = ConditionSites.new(path, ignored,
+                                     [present, nonempty])
       Prism.parse(source).value.accept(collector)
       collector.sites
     end
@@ -20,7 +30,10 @@ module PathCoverage
     # The source and sites of the covered file at full_path.
     def self.parse(full_path, config)
       source = File.read(full_path)
-      { source:, sites: sites(source, config.relative(full_path)) }
+      path = config.relative(full_path)
+      treated = %w[present nonempty].map { config.treated(_1, path) }
+      ignored = config.ignored
+      { source:, sites: sites(source, path, ignored, *treated) }
     end
 
     # True for a call to a named method with arguments and no
@@ -73,13 +86,24 @@ module PathCoverage
     class ConditionSites < Prism::Visitor
       include ManifestBlocks
       include ManifestCase
+      include ManifestChains
       include ManifestChoices
-
-      # Starts with no sites found.
-      def initialize(path)
+      include ManifestFolding
+      include ManifestIgnoring
+      include ManifestWrites
+
+      # Starts with no sites found, to find none named by an
+      # operator in ignored, and to take a call to a method named
+      # in present as never nil, and to one in nonempty as true
+      # exactly when its receiver has items.
+      def initialize(path, ignored, (present, nonempty))
         @path = path
+        @ignored = ignored
+        @present = present
+        @nonempty = nonempty
         @sites = {}
         @notes = nil
+        @inner = nil
         super()
       end
 
@@ -118,10 +142,11 @@ module PathCoverage
         add_site(node)
       end
 
-      # Notes a block method's call as a site, when its block's
-      # every call can be seen; any other call is no site, though
-      # a condition inside it may be.
+      # Notes a &. chain as a site, or a block method's call, when
+      # its block's every call can be seen; any other call is no
+      # site, though a condition inside it may be.
       def visit_call_node(node)
+        return add_site(node) if safe_chain?(node)
         return super unless block_site?(node)
 
         add_site(node)
@@ -130,12 +155,17 @@ module PathCoverage
       # Notes node as a site, named where it starts: an if or an
       # unless at its keyword. It claims its place first, so a
       # site found inside one of its leaves or arms follows it.
+      # While a leaf is being visited, any site is collected as
+      # part of that leaf instead, as it is part of one expression.
       def add_site(node)
+        return visit_child_nodes(node) if ignored?(node)
+        return @inner << nested_condition_of(node) if @inner
+
         site = Site.at(@path, site_loc(node))
         @sites[site] = nil
         outer = @notes
         @notes = { commands: [], fixed: {} }
-        condition = condition_of(node)
+        condition = scoped { condition_of(node) }
         @sites[site] = condition.with(**@notes)
         @notes = outer
       end
@@ -143,11 +173,14 @@ module PathCoverage
       # node as a Condition, operands and all, named by its
       # operator as written; a ternary is named ?:, an if if and
       # an unless unless, their operands a predicate and arms; a
-      # case case, its operands its arms.
+      # case case, its operands its arms; a write ||= or &&=, its
+      # operands its target and its right side; a &. chain &., its
+      # operands its receivers.
       def condition_of(node)
+        return write_condition(node) if write?(node)
         return choice_of(node) if CHOICE_TYPES.include?(node.type)
         return case_condition(node) if node.type == :case_node
-        return block_condition(node) if node.type == :call_node
+        return call_condition(node) if node.type == :call_node
 
         Condition.new(
           operator: node.operator, operands: operands_of(node),
@@ -157,12 +190,17 @@ module PathCoverage
 
       # node's operands: a chain of the same operator flattened
       # into one list, the other operator nested as a Condition,
-      # anything else a leaf's byte range.
+      # as is a &. chain, its value its last leaf, anything else a
+      # leaf's byte range.
       def operands_of(node)
         [node.left, node.right].flat_map do |written|
           operand = grouped(written)
+          next [leaf(operand)] if ignored?(operand)
           next operands_of(operand) if operand.type == node.type
           next [condition_of(operand)] if operator?(operand)
+          if safe_chain?(operand)
+            next [chain_condition(operand, value: true)]
+          end
 
           [leaf(operand)]
         end
@@ -179,17 +217,18 @@ module PathCoverage
         OPERATOR_TYPES.include?(node.type)
       end
 
-      # The byte range of a leaf operand, once any site inside
-      # it is noted too, and the range noted among its site's
-      # commands and fixed leaves where it is one.
+      # The byte range of a leaf operand, noted among its site's
+      # commands and fixed leaves where it is one; or, when sites
+      # that fold are found inside it, the leaf with them nested.
       def leaf(operand)
-        operand.accept(self)
+        inner = collected { operand.accept(self) }
         loc = operand.location
         range = loc.start_offset...loc.end_offset
         @notes[:commands] << range if Manifest.command?(operand)
         outcome = Manifest.fixed_outcome(operand)
         @notes[:fixed][range] = outcome if outcome
-        range
+        nonempty = nonempty_call?(operand, inner)
+        contained(inner, range, nonempty:)
       end
 
       # The one statement inside a parenthesised operand, or the

data/lib/path_coverage/manifest_blocks.rb

@@ -12,13 +12,31 @@ module PathCoverage
     # True for a call whose block's every call can be seen: to a
     # block method, on a receiver, with no arguments, which can
     # make it ignore its block, not by &., which skips it for
-    # nil, and with a block of one expression.
+    # nil, and with a block of one expression that is a value,
+    # so can be wrapped: not break, next or return.
     def block_site?(node)
-      BLOCK_PATHS.key?(node.name.to_s) && !node.receiver.nil? &&
-        node.arguments.nil? && !node.safe_navigation? &&
-        !block_expression(node.block).nil?
+      return false unless BLOCK_PATHS.key?(node.name.to_s)
+
+      plain_call?(node) && value?(block_expression(node.block))
+    end
+
+    # True for a call on a receiver, with no arguments, and not
+    # by &.
+    def plain_call?(node)
+      !node.receiver.nil? && node.arguments.nil? &&
+        !node.safe_navigation?
+    end
+
+    # True for a block's one expression that is a value, so can
+    # be wrapped: nil, for no one expression, is not, nor is a
+    # jump.
+    def value?(body)
+      !body.nil? && !JUMPS.include?(body.type)
     end
 
+    # The expressions that leave a block, so are no value.
+    JUMPS = %i[break_node next_node return_node].freeze
+
     # The one expression of block, nil for no block, a block
     # passed as an argument, or one of other than one expression.
     def block_expression(block)
@@ -35,23 +53,44 @@ module PathCoverage
     # among the commands when it is no bare argument.
     def block_condition(node)
       node.receiver.accept(self)
-      body = block_expression(node.block)
-      body.accept(self)
-      @notes[:commands] << extent_of(body) if bare_less?(body)
+      body = block_body(node.block)
       Condition.new(
         operator: node.name.to_s,
-        operands: [extent_of(node.receiver), extent_of(body)],
+        operands: [extent_of(node.receiver), body],
         extent: extent_of(node)
       )
     end
 
+    # The byte range of block's one expression, any site in it
+    # visited as one of its own, as the block runs once per item;
+    # noted among the commands when it is no bare argument.
+    def block_body(block)
+      body = block_expression(block)
+      scoped { body.accept(self) }
+      range = extent_of(body)
+      @notes[:commands] << range if bare_less?(body)
+      range
+    end
+
     # True for an expression that is no bare argument: a command
-    # call, or an and or an or.
+    # call, an and or an or, or a modifier, eg x unless y.
     def bare_less?(node)
-      return true if Manifest.command?(node)
+      return true if Manifest.command?(node) || modifier?(node)
 
       %i[and_node or_node].include?(node.type) &&
         %w[and or].include?(node.operator)
     end
+
+    # True for a modifier if, unless or rescue, eg x if y: one
+    # with no end keyword, a ternary being no modifier.
+    def modifier?(node)
+      case node.type
+      when :rescue_modifier_node then true
+      when :unless_node then node.end_keyword_loc.nil?
+      when :if_node
+        !node.if_keyword_loc.nil? && node.end_keyword_loc.nil?
+      else false
+      end
+    end
   end
 end

data/lib/path_coverage/manifest_chains.rb

@@ -0,0 +1,76 @@
+require_relative 'condition'
+
+module PathCoverage
+  # The part of the manifest's visitor that builds the sites of
+  # safe-navigation chains, eg user&.account&.owner. It relies
+  # on its includer's extent_of.
+  module ManifestChains
+    # The calls of node's chain, outermost first, eg owner then
+    # account for user&.account&.owner; none for a node that is
+    # no call.
+    def chain_calls(node)
+      calls = []
+      while node&.type == :call_node
+        calls << node
+        node = node.receiver
+      end
+      calls
+    end
+
+    # True for a call whose chain has a &. in it, eg
+    # user&.name.upcase.
+    def safe_chain?(node)
+      chain_calls(node).any?(&:safe_navigation?)
+    end
+
+    # A call that is a site as a Condition: a &. chain's, or a
+    # block method call's. It relies on its includer's
+    # block_condition.
+    def call_condition(node)
+      return block_condition(node) unless safe_chain?(node)
+
+      chain_condition(node, value: false)
+    end
+
+    # A &. chain as a Condition named &.: its leaves are the
+    # receivers of its &. calls, innermost first, each nil or
+    # not nil, and, with value, the whole chain's value last, as
+    # when it is an operand of an && or an if's predicate. Any
+    # site in a call's arguments or block, or in the chain's
+    # first receiver, is a site of its own. A chain that is no
+    # bare argument, eg a command call, is noted among the
+    # site's commands, to be parenthesised.
+    def chain_condition(node, value:)
+      calls = chain_calls(node)
+      visit_chain(calls)
+      safe = calls.select(&:safe_navigation?).reverse
+      receivers = safe.map { |call| receiver_of(call) }
+      extent = extent_of(node)
+      @notes[:commands] << extent if Manifest.command?(node)
+      operands = value ? [*receivers, extent] : receivers
+      Condition.new(operator: SAFE, operands:, extent:)
+    end
+
+    # The byte range of a &. call's receiver, noted among its
+    # site's fixed leaves as :present, never nil, when it is a
+    # call to a method treated as present.
+    def receiver_of(call)
+      receiver = call.receiver
+      range = extent_of(receiver)
+      named = receiver.type == :call_node &&
+              @present.include?(receiver.name.to_s)
+      @notes[:fixed][range] = :present if named
+      range
+    end
+
+    # Visits the sites inside a chain's calls' arguments and
+    # blocks, and inside its first receiver, eg (a || b) in
+    # (a || b)&.size, but never a call of the chain itself.
+    def visit_chain(calls)
+      calls.each do |call|
+        [call.arguments, call.block].compact.each { _1.accept(self) }
+      end
+      calls.last.receiver&.accept(self)
+    end
+  end
+end

data/lib/path_coverage/manifest_choices.rb

@@ -11,10 +11,12 @@ module PathCoverage
     # being an if_node with no if keyword.
     CHOICE_TYPES = %i[if_node unless_node].freeze
 
-    # Where node's site starts: an if's or an unless's keyword,
-    # which a modifier's statement comes before; anything
-    # else's own start.
+    # Where node's site starts: a &. chain's start; a block
+    # method's call at its method; an if's or an unless's
+    # keyword, which a modifier's statement comes before;
+    # anything else's own start.
     def site_loc(node)
+      return node.location if safe_chain?(node)
       return node.message_loc if node.type == :call_node
       return node.location unless CHOICE_TYPES.include?(node.type)
       return node.location if ternary?(node)
@@ -69,11 +71,11 @@ module PathCoverage
     end
 
     # An if's arm, statements its code, which never folds into
-    # the if's site; any site inside it is a site of its own.
-    # An arm with no statements has no extent.
+    # the if's site; as a new scope, any site inside it is a site
+    # of its own. An arm with no statements has no extent.
     def statement_arm(kind, statements)
-      statements&.accept(self)
-      extent = statements && extent_of(statements)
+      scoped { statements&.accept(self) }
+      extent = statements ? extent_of(statements) : nil
       Arm.new(kind:, extent:, body: nil)
     end
 
@@ -85,7 +87,7 @@ module PathCoverage
         return [statement_arm(:else, subsequent.statements)]
       end
 
-      subsequent.accept(self)
+      scoped { subsequent.accept(self) }
       extent = extent_of(subsequent)
       [Arm.new(kind: :else, extent:, body: nil)]
     end
@@ -100,19 +102,25 @@ module PathCoverage
     end
 
     # One arm of a ternary, statements its code: a condition
-    # folds in as its body, being part of the one expression;
-    # any site inside a plain arm is a site of its own.
+    # folds in as its body, being part of the one expression, as
+    # does a plain arm with sites inside it, its value its last
+    # leaf; a plain arm with none has no body.
     def arm_of(kind, statements)
       written = grouped(statements.body.first)
-      body = condition_of(written) if foldable?(written)
-      statements.accept(self) if body.nil?
-      Arm.new(kind:, extent: extent_of(statements), body:)
+      extent = extent_of(statements)
+      body = if foldable?(written)
+               condition_of(written)
+             else
+               inner = collected { statements.accept(self) }
+               inner.empty? ? nil : contained(inner, extent)
+             end
+      Arm.new(kind:, extent:, body:)
     end
 
     # True for a condition that folds into a ternary's site:
-    # an &&, ||, and, or, or a ternary.
+    # an &&, ||, and, or, or a ternary, none of them ignored.
     def foldable?(node)
-      operator?(node) || ternary?(node)
+      (operator?(node) || ternary?(node)) && !ignored?(node)
     end
 
     # True for a ternary, an if with no if keyword.
@@ -121,10 +129,15 @@ module PathCoverage
     end
 
     # A ternary's or an if's predicate as its operand: an && or
-    # || nested as a Condition, anything else a leaf.
+    # || nested as a Condition, as is a &. chain, its value its
+    # last leaf, anything else a leaf.
     def predicate_of(node)
-      predicate = node.predicate
+      predicate = grouped(node.predicate)
+      return leaf(predicate) if ignored?(predicate)
       return condition_of(predicate) if operator?(predicate)
+      if safe_chain?(predicate)
+        return chain_condition(predicate, value: true)
+      end
 
       leaf(predicate)
     end

data/lib/path_coverage/manifest_folding.rb

@@ -0,0 +1,91 @@
+require_relative 'condition'
+
+module PathCoverage
+  # The part of the manifest's visitor that folds every site in one
+  # expression into one site. While a leaf is visited, each site
+  # found in it, the leaf itself included, is collected as a nested
+  # Condition of that leaf, rather than noted as a site of its own.
+  # A new scope, eg a block's body or an if's arm, stops the
+  # collecting, so a site in it is a site of its own. It relies on
+  # its includer's condition_of, chain_condition, safe_chain? and
+  # extent_of.
+  module ManifestFolding
+    # node's Condition as a site nested in a leaf: a &. chain's
+    # with its value as its last leaf, as its leaf's outcome
+    # follows from it.
+    def nested_condition_of(node)
+      return chain_condition(node, value: true) if safe_chain?(node)
+
+      condition_of(node)
+    end
+
+    # The Conditions of the sites found while yielding, each one
+    # collected rather than noted as a site of its own.
+    def collected
+      outer = @inner
+      @inner = []
+      yield
+      @inner
+    ensure
+      @inner = outer
+    end
+
+    # Yields with no collecting, so a site found is one of its own:
+    # for a new scope, eg a block's body or an if's arm.
+    def scoped
+      outer = @inner
+      @inner = nil
+      yield
+    ensure
+      @inner = outer
+    end
+
+    # range as a leaf, or, with inner sites found in it, a Condition
+    # named contains: those sites, then range, the leaf's outcome,
+    # fixed as :nonempty when nonempty. A leaf that is wholly one
+    # block method's call whose value follows from its path is
+    # that call alone, needing no outcome of its own.
+    def contained(inner, range, nonempty: false)
+      return range if inner.empty?
+
+      only = inner.first
+      if inner.size == 1 && only.extent == range &&
+         VALUED.include?(only.operator)
+        return only
+      end
+
+      fixed = nonempty ? { range => :nonempty } : {}
+      Condition.new(operator: CONTAINS, operands: [*inner, range],
+                    extent: range, fixed:)
+    end
+
+    # True for a call, with no arguments or block, to a method
+    # treated as nonempty, eg any?, whose receiver, parenthesised
+    # or not, is one of inner, the sites found in it: its outcome
+    # then follows from that site's path. It relies on its
+    # includer's grouped.
+    def nonempty_call?(node, inner)
+      return false unless node.type == :call_node
+      return false if node.arguments || node.block || !node.receiver
+
+      receiver = extent_of(grouped(node.receiver))
+      @nonempty.include?(node.name.to_s) &&
+        inner.any? { |site| site.extent == receiver }
+    end
+
+    # A block's body is a new scope: it runs once per item.
+    def visit_block_node(node)
+      scoped { super }
+    end
+
+    # A lambda's body is a new scope: it runs when called.
+    def visit_lambda_node(node)
+      scoped { super }
+    end
+
+    # A def's body is a new scope: it runs when called.
+    def visit_def_node(node)
+      scoped { super }
+    end
+  end
+end

data/lib/path_coverage/manifest_ignoring.rb

@@ -0,0 +1,35 @@
+module PathCoverage
+  # The part of the manifest's visitor that leaves out the sites
+  # of ignored operators, eg ignore '&&='. An ignored node is no
+  # site, though a site inside it may be; nested in a site, it
+  # is a leaf. It relies on its includer's @ignored, ternary?
+  # and safe_chain?.
+  module ManifestIgnoring
+    # The operator of each node type that always names one kind
+    # of site.
+    NAMED = { unless_node: 'unless', case_node: 'case' }.freeze
+
+    # True for a node whose operator is ignored.
+    def ignored?(node)
+      @ignored.include?(operator_of(node))
+    end
+
+    # The operator naming node's kind of site, eg ?: for a
+    # ternary or any? for a block method's call; nil for a
+    # node with none.
+    def operator_of(node)
+      type = node.type
+      return NAMED[type] if NAMED.key?(type)
+      return ternary?(node) ? '?:' : 'if' if type == :if_node
+      return call_operator(node) if type == :call_node
+
+      node.respond_to?(:operator) ? node.operator : nil
+    end
+
+    # The operator of a call: &. for a &. chain, else its
+    # method's name, eg any?.
+    def call_operator(node)
+      safe_chain?(node) ? '&.' : node.name.to_s
+    end
+  end
+end

data/lib/path_coverage/manifest_writes.rb

@@ -0,0 +1,67 @@
+require_relative 'condition'
+
+module PathCoverage
+  # The part of the manifest's visitor that builds the sites of
+  # ||= and &&= writes, eg @clock ||= Clock.new. It relies on
+  # its includer's add_site, bare_less? and extent_of.
+  module ManifestWrites
+    # Every node type of a ||= or &&= write, by its target: a
+    # variable of each kind, a constant, a constant path, an
+    # attribute, eg self.size, and an index, eg store[key].
+    WRITE_TYPES = %w[
+      local_variable instance_variable class_variable
+      global_variable constant constant_path call index
+    ].flat_map do |target|
+      %W[#{target}_or_write_node #{target}_and_write_node]
+    end.map(&:to_sym).freeze
+
+    # Notes each kind of write as a site, eg
+    # visit_index_or_write_node for store[key] ||= 0.
+    WRITE_TYPES.each do |type|
+      define_method(:"visit_#{type}") do |node|
+        write?(node) ? add_site(node) : visit_child_nodes(node)
+      end
+    end
+
+    # True for a ||= or &&= write that is a site: any but one
+    # through &., eg box&.size ||= 3, which a nil box skips whole,
+    # its target never looked at, so neither of its paths taken.
+    def write?(node)
+      WRITE_TYPES.include?(node.type) && !safe_write?(node)
+    end
+
+    # True for a write through &., eg box&.size ||= 3.
+    def safe_write?(node)
+      node.respond_to?(:safe_navigation?) && node.safe_navigation?
+    end
+
+    # A write as a Condition, named by its operator: its one leaf
+    # its target, then its right side as an arm, taken when the
+    # target is false for ||=, true for &&=. The target is a
+    # leaf the rewriter never reads again, as reading it could
+    # call a method twice; its outcome follows from whether the
+    # arm ran. Any site inside the write, eg in an index or on
+    # the right side, is a site of its own. A right side that is
+    # no bare argument, eg a command call, is noted among the
+    # site's commands, to be parenthesised.
+    def write_condition(node)
+      visit_child_nodes(node)
+      value = extent_of(node.value)
+      @notes[:commands] << value if bare_less?(node.value)
+      arm = Arm.new(kind: :then, extent: value, body: nil)
+      Condition.new(
+        operator: node.operator, operands: [target_of(node), arm],
+        extent: extent_of(node)
+      )
+    end
+
+    # The byte range of a write's target: from its start to its
+    # operator, less any space between, eg `store[key]`.
+    def target_of(node)
+      start = node.location.start_offset
+      before = node.operator_loc.start_offset - start
+      text = node.location.slice.byteslice(0, before)
+      start...(start + text.rstrip.bytesize)
+    end
+  end
+end

data/lib/path_coverage/merge.rb

@@ -12,11 +12,15 @@ module PathCoverage
     end
 
     # One site paths hash, as Result#paths gives them, each
-    # path's count the sum of every run's; runs of the same
-    # source list the same paths in the same order.
+    # path's count the sum of every run's. Runs that list a
+    # site's paths differently raise, as adding their counts by
+    # position would credit one path's count to another.
     def self.paths(runs)
       runs.reduce do |total, run|
-        total.merge(run) do |_site, mine, theirs|
+        total.merge(run) do |site, mine, theirs|
+          same = mine.map { _1[:path] } == theirs.map { _1[:path] }
+          raise ArgumentError, "runs differ at #{site}" unless same
+
           mine.zip(theirs).map do |a, b|
             { path: a[:path], count: a[:count] + b[:count] }
           end
@@ -24,6 +28,18 @@ module PathCoverage
       end
     end
 
+    # One method paths hash, { site => { path => count } }, as
+    # the recorder counts them, each path's count the sum of
+    # every run's, eg [true, false] taken once in each of two
+    # runs is taken twice.
+    def self.method_paths(runs)
+      runs.reduce do |total, run|
+        total.merge(run) do |_site, mine, theirs|
+          mine.merge(theirs) { |_path, a, b| a + b }
+        end
+      end
+    end
+
     # One operand's counts from two runs, added; a fixed leaf's
     # only comes from the source, so either run's will do.
     def self.sum(mine, theirs)

data/lib/path_coverage/post.rb

@@ -6,18 +6,18 @@ module PathCoverage
   # for runs whose own files are thrown away, eg a failing
   # docker build step.
   module Post
-    # POSTs operands and paths, as the JSON report, to url,
-    # never through an http_proxy, which could not reach a
-    # collector local to the run. A collector that cannot be
-    # reached, or does not answer within a second, is passed
-    # over in silence: the run's own output and exit status
-    # must stay as they are.
-    def self.deliver(operands, url, paths = {})
+    # POSTs operands and paths, as the JSON report with its
+    # fingerprint, to url, never through an http_proxy,
+    # which could not reach a collector local to the run. A
+    # collector that cannot be reached, or does not answer
+    # within a second, is passed over in silence: the run's own
+    # output and exit status must stay as they are.
+    def self.deliver(operands, url, paths = {}, fingerprint: {})
       uri = URI(url)
       http = Net::HTTP.new(uri.host, uri.port, nil)
       http.open_timeout = http.read_timeout = 1
       headers = { 'Content-Type' => 'application/json' }
-      body = JsonWriter.json(operands, paths)
+      body = JsonWriter.json(operands, paths, fingerprint:)
       http.post(uri.path, body, headers)
     rescue StandardError
       nil