necropsy 0.1.0 → 0.3.0

data/lib/necropsy/confidence/scorer.rb

@@ -5,106 +5,133 @@ require 'date'
 module Necropsy
   module Confidence
     class Scorer
-      def initialize(graph:, reachability:, project:)
+      RUBY_HOOKS = %w[
+        inherited included extended prepended method_added singleton_method_added
+        const_missing method_missing respond_to_missing?
+      ].freeze
+      RUBY_PROTOCOLS = %w[
+        == eql? hash <=> to_s to_str to_a to_h to_proc inspect coerce
+        succ initialize_copy marshal_dump marshal_load
+      ].freeze
+      BUILTIN_IMPLICIT_CALLERS = [
+        {
+          name_pattern: /^on_/,
+          owner_ancestors: ['RuboCop::Cop::Base'],
+          reason: 'RuboCop Commissioner dispatches on_* callbacks'
+        }
+      ].freeze
+
+      def initialize(graph:, reachability:, project:, clock: Clock.new)
         @graph = graph
         @reachability = reachability
         @project = project
+        @clock = clock
+        @source_lines = {}
       end
 
       def findings
         graph.method_nodes.filter_map do |node|
           next if node.test
+          next unless graph.analyze_source?(node.file)
+          next if rails_generated?(node)
 
-          classification = classification_for(node)
+          blockers = graph.matching_blockers(node)
+          classification = classification_for(node, blockers)
           next unless classification
 
-          score, level, reasons = score_for(node, classification)
+          score, level, reasons, score_components = score_for(node, classification, blockers)
           Finding.new(
             node: node,
             classification: classification,
             confidence: level,
             score: score,
+            score_components: score_components,
             reasons: reasons,
-            evidences: graph.incoming_edges(node.id).flat_map(&:evidences) + graph.alive_evidences(node.id)
+            evidences: graph.incoming_edges(node.graph_id).flat_map(&:evidences) + graph.alive_evidences(node.graph_id),
+            blockers: blockers
           )
         end
       end
 
       private
 
-      attr_reader :graph, :reachability, :project
+      attr_reader :graph, :reachability, :project, :clock
 
-      def classification_for(node)
-        if reachability.runtime_alive.include?(node.id)
-          return :unused if graph.dynamic_enabled? && !graph.dynamic_alive?(node.id)
+      def classification_for(node, blockers)
+        return nil if graph.dynamic_alive?(node.graph_id)
 
+        if reachability.runtime_paths.key?(node.graph_id) || reachability.external_paths.key?(node.graph_id)
           nil
-        elsif reachability.test_alive.include?(node.id)
+        elsif blockers.any?
+          :blocked
+        elsif reachability.test_paths.key?(node.graph_id)
           :test_only_reachable
         else
           :unreachable
         end
       end
 
-      def score_for(node, classification)
+      def score_for(node, classification, blockers)
         reasons = []
         score = base_score(classification)
+        components = [score_component("base(#{classification})", score, 'Base classification score')]
+
+        if blockers.any?
+          components << score_component('matching_blocker', 0.0, 'Incomplete runtime dispatch matches this definition')
+          reasons << "Blocked by #{blockers.length} unresolved runtime dispatch#{'es' unless blockers.one?}."
+        end
 
-        if graph.uncertainties(node.id).any?
+        if graph.uncertainties(node.graph_id).any?
           score -= 0.35
+          components << score_component('near_metaprogramming', -0.35, 'Unresolved metaprogramming nearby')
           reasons << 'Lowered because this node is near unresolved metaprogramming.'
         end
 
         if graph.class_info(node.owner)&.dynamic
           score -= 0.25
+          components << score_component('dynamic_owner', -0.25, 'Owner defines dynamic dispatch')
           reasons << 'Lowered because the owner class defines dynamic dispatch.'
         end
 
         if generated_accessor?(node)
           score -= 0.2
+          components << score_component('generated_accessor', -0.2, 'Generated by an accessor DSL')
           reasons << 'Lowered because this node is generated by a Ruby accessor DSL.'
         end
 
-        static_count = graph.profiles.count { |profile| profile.kind == :static }
-        if static_count > 1
-          score += [static_count - 1, 3].min * 0.04
-          reasons << "Raised because #{static_count} static analyzers participated."
+        if (reason = implicit_call_context(node))
+          score -= 0.4
+          components << score_component('implicit_caller', -0.4, reason)
+          reasons << "Lowered because #{reason}."
         end
 
-        evidence_analyzers = graph.incoming_edges(node.id).flat_map(&:evidences).map(&:analyzer).uniq
-        if evidence_analyzers.length > 1
-          score += 0.08
-          reasons << 'Raised because multiple analyzers agree on incoming reachability evidence.'
-        end
+        add_runtime_unobserved_annotation(node, reasons, components)
 
-        if classification == :unreachable && graph.dynamic_enabled? && !graph.dynamic_alive?(node.id)
-          score += 0.25
-          reasons << 'Static unreachable and absent from dynamic observations.'
-        end
+        add_quarantine_annotation(node, classification, reasons, components)
 
-        if classification == :unreachable && quarantine_expired?(node)
-          score = [score, 0.95].max
-          reasons << 'Raised because quarantine annotation has expired without alive evidence.'
-        end
+        clamped_score = score.clamp(0.0, 1.0)
+        components << score_component('score_clamp', clamped_score - score, 'Clamped to the 0.0–1.0 range') if clamped_score != score
+        [clamped_score, level_for(clamped_score), reasons, components]
+      end
 
-        if classification == :unused
-          days = observation_days
-          if days && days < project.config.min_observation_days
-            score -= 0.3
-            reasons << "Observation window is #{days} days, below the configured minimum."
-          else
-            reasons << 'Reachable statically but never observed dynamically.'
-          end
-        end
+      def score_component(name, value, details)
+        ScoreComponent.new(name: name, value: value.round(4), details: details)
+      end
+
+      def add_runtime_unobserved_annotation(node, reasons, components)
+        return unless graph.dynamic_observation?
+        return if graph.dynamic_alive?(node.graph_id)
 
-        score = [[score, 0.0].max, 1.0].min
-        [score, level_for(score), reasons]
+        components << score_component('runtime_unobserved', 0.0, 'Informational only; deadness is unchanged')
+        reasons << 'Runtime observations did not include this definition; classification and confidence are unchanged.'
       end
 
       def base_score(classification)
+        return 0.25 if classification == :blocked
+
         case classification
         when :unreachable
-          graph.profiles.any? { |profile| profile.name == :rta } ? 0.78 : 0.62
+          0.62
         when :test_only_reachable
           0.55
         when :unused
@@ -118,6 +145,62 @@ module Necropsy
         %i[attr_reader attr_writer attr_accessor struct_new data_define].include?(node.defined_via)
       end
 
+      def rails_generated?(node)
+        node.defined_via.to_s.start_with?('rails_')
+      end
+
+      def implicit_call_reason(node)
+        return "#{node.name} is a Ruby hook invoked by the VM" if RUBY_HOOKS.include?(node.name)
+        return "#{node.name} is a Ruby protocol method invoked implicitly" if RUBY_PROTOCOLS.include?(node.name)
+
+        rule = implicit_caller_rules.find do |candidate|
+          candidate[:name_pattern].match?(node.name) && owner_matches?(node.owner, candidate[:owner_ancestors])
+        end
+        return unless rule
+
+        rule[:reason] || 'the method matches a configured implicit caller'
+      end
+
+      def implicit_call_context(node)
+        direct_reason = implicit_call_reason(node)
+        return direct_reason if direct_reason
+
+        root_id = implicit_paths[node.graph_id]
+        "it is reachable from implicitly invoked #{root_id}" if root_id
+      end
+
+      def implicit_paths
+        @implicit_paths ||= begin
+          roots = graph.method_nodes.reject(&:test).select { |node| implicit_call_reason(node) }.map(&:graph_id)
+          paths = roots.to_h { |node_id| [node_id, node_id] }
+          queue = roots.dup
+          head = 0
+
+          while head < queue.length
+            node_id = queue.fetch(head)
+            head += 1
+            graph.edges_from(node_id).each_key do |callee_id|
+              next if paths.key?(callee_id)
+
+              paths[callee_id] = paths.fetch(node_id)
+              queue << callee_id
+            end
+          end
+          paths
+        end
+      end
+
+      def implicit_caller_rules
+        BUILTIN_IMPLICIT_CALLERS + project.config.implicit_callers
+      end
+
+      def owner_matches?(owner, ancestors)
+        return true if ancestors.empty?
+        return false unless owner
+
+        ancestors.any? { |ancestor| graph.owner_reachable_from_ancestor?(owner, ancestor) }
+      end
+
       def level_for(score)
         return :certain if score >= 0.9
         return :high if score >= 0.7
@@ -126,31 +209,71 @@ module Necropsy
         :low
       end
 
-      def observation_days
-        graph.observation.values.filter_map do |value|
-          next unless value.is_a?(Hash)
-
-          value['days'] || value[:days] || value['observation_days'] || value[:observation_days]
-        end.map(&:to_i).max
-      end
-
-      def quarantine_expired?(node)
-        since = quarantine_since(node)
-        return false unless since
+      def add_quarantine_annotation(node, classification, reasons, components)
+        status = quarantine_status(node, classification)
+        return unless status
 
-        since <= Date.today - project.config.quarantine_days
+        case status
+        when :review_required
+          components << score_component(
+            'quarantine_review_required', 0.0, 'Quarantine expired; deadness is unchanged'
+          )
+          reasons << 'Quarantine annotation has expired and requires review; classification and confidence are unchanged.'
+        when :invalid
+          components << score_component(
+            'quarantine_invalid_date', 0.0, 'Invalid quarantine date; deadness is unchanged'
+          )
+          reasons << 'Quarantine annotation has an invalid since date; classification and confidence are unchanged.'
+        when :fingerprint_required
+          components << score_component(
+            'quarantine_fingerprint_required', 0.0, 'Legacy quarantine requires an exact physical fingerprint'
+          )
+          reasons << 'Quarantine annotation requires a physical fingerprint before it can apply to this definition.'
+        when :stale_fingerprint
+          components << score_component(
+            'quarantine_stale_fingerprint', 0.0, 'Quarantine fingerprint does not match this physical definition'
+          )
+          reasons << 'Quarantine annotation is stale or belongs to a different physical definition.'
+        end
       end
 
-      def quarantine_since(node)
+      def quarantine_status(node, classification)
         path = File.join(project.root, node.file)
         return nil unless File.exist?(path)
 
-        window = File.readlines(path, chomp: true)[[node.line - 4, 0].max, 4] || []
-        annotation = window.find { |line| line.include?('necropsy:quarantine') && line.match?(/\bsince=/) }
-        return nil unless annotation
+        lines = @source_lines[path] ||= File.readlines(path, chomp: true)
+        annotation = node.line > 1 ? lines[node.line - 2] : nil
+        return nil unless annotation&.include?('necropsy:quarantine') && annotation.match?(/\bsince=/)
+
+        fingerprints = quarantine_fingerprints(annotation)
+        fingerprint_status = if fingerprints.nil?
+                               :fingerprint_required
+                             elsif fingerprints.include?(node.physical_fingerprint(classification))
+                               :matched
+                             else
+                               :stale_fingerprint
+                             end
+
+        raw_since = annotation[/\bsince=([^\s]+)/, 1]
+        return :invalid unless raw_since
+
+        since = Date.iso8601(raw_since)
+        return fingerprint_status unless fingerprint_status == :matched
+
+        since <= clock.date - project.config.quarantine_days ? :review_required : :active
+      rescue ArgumentError, TypeError
+        :invalid
+      rescue SystemCallError
+        nil
+      end
+
+      def quarantine_fingerprints(annotation)
+        single = annotation[/\bfingerprint=([0-9a-f]{64})(?:\s|$)/, 1]
+        multiple = annotation[/\bfingerprints=([0-9a-f]{64}(?:,[0-9a-f]{64})*)(?:\s|$)/, 1]
+        return [single] if single
+        return multiple.split(',') if multiple
+        return [] if annotation.match?(/\bfingerprints?=/)
 
-        Date.iso8601(annotation[/\bsince=([0-9-]+)/, 1])
-      rescue ArgumentError, SystemCallError
         nil
       end
     end