necropsy 0.1.0

data/lib/necropsy/graph/call_graph.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class CallGraph
+    attr_reader :nodes, :call_sites, :instantiated_classes, :entry_points, :profiles, :observation, :class_infos,
+                :entrypoint_hints
+
+    def initialize(scan_result)
+      @nodes = {}
+      @edges = Hash.new { |hash, key| hash[key] = {} }
+      @call_sites = scan_result.call_sites
+      @instantiated_classes = scan_result.instantiated_classes.dup
+      @class_infos = scan_result.class_infos.to_h { |info| [info.id, info] }
+      @entrypoint_hints = scan_result.entrypoint_hints
+      @entry_points = []
+      @profiles = []
+      @uncertainties = scan_result.uncertainties
+      @dynamic_alive = {}
+      @observation = {}
+      scan_result.nodes.each { |node| add_node(node) }
+      retain_known_instantiated_classes
+    end
+
+    def add_node(node)
+      nodes[node.id] ||= node
+    end
+
+    def add_entry_point(node_id, reason)
+      return unless nodes.key?(node_id)
+
+      entry = EntryPoint.new(node_id: node_id, reason: reason)
+      entry_points << entry unless entry_points.include?(entry)
+    end
+
+    def apply_result(result)
+      result.edge_evidences.each { |edge| add_edge(edge.caller_id, edge.callee_id, edge.evidence) }
+      result.alive_evidences.each { |alive| add_alive(alive.node_id, alive.evidence) }
+      result.uncertainties.each { |node_id, messages| uncertainties[node_id].concat(Array(messages)) }
+      observation.merge!(result.observation) { |_key, left, right| merge_observation(left, right) }
+    end
+
+    def add_profile(profile)
+      profiles << profile
+    end
+
+    def add_edge(caller_id, callee_id, evidence)
+      return unless nodes.key?(caller_id) && nodes.key?(callee_id)
+
+      @edges[caller_id][callee_id] ||= []
+      @edges[caller_id][callee_id] << evidence
+    end
+
+    def add_alive(node_id, evidence)
+      return unless nodes.key?(node_id)
+
+      @dynamic_alive[node_id] ||= []
+      @dynamic_alive[node_id] << evidence
+    end
+
+    def dynamic_alive?(node_id)
+      @dynamic_alive.key?(node_id)
+    end
+
+    def alive_evidences(node_id)
+      @dynamic_alive[node_id] || []
+    end
+
+    def dynamic_enabled?
+      @dynamic_alive.any? || observation.any?
+    end
+
+    def edges_from(node_id)
+      @edges[node_id] || {}
+    end
+
+    def edges
+      @edges.flat_map do |caller_id, callees|
+        callees.map do |callee_id, evidences|
+          Edge.new(caller_id: caller_id, callee_id: callee_id, evidences: evidences)
+        end
+      end
+    end
+
+    def incoming_edges(node_id)
+      edges.select { |edge| edge.callee_id == node_id }
+    end
+
+    def uncertainties(node_id = nil)
+      return @uncertainties unless node_id
+
+      @uncertainties[node_id] || []
+    end
+
+    def method_nodes
+      nodes.values.select(&:method?)
+    end
+
+    def class_info(owner)
+      class_infos[owner]
+    end
+
+    def descendants_of(owner)
+      class_infos.keys.select { |candidate| candidate == owner || ancestor_chain(candidate).include?(owner) }
+    end
+
+    def modules_for(owner)
+      info = class_info(owner)
+      return [] unless info
+
+      (info.prepends + info.includes + info.extends).uniq
+    end
+
+    def candidate_nodes(message)
+      method_nodes.select { |node| node.name == message }
+    end
+
+    def resolve_call_site(site, rta: false)
+      candidates = candidates_for_receiver(site)
+      candidates = candidates.select { |node| rta_candidate?(node, site) } if rta
+      candidates
+    end
+
+    def to_h
+      {
+        'nodes' => nodes.values.map(&:to_h),
+        'edges' => edges.map(&:to_h),
+        'entry_points' => entry_points.map(&:to_h),
+        'class_infos' => class_infos.values.map(&:to_h),
+        'instantiated_classes' => instantiated_classes.to_a.sort,
+        'profiles' => profiles.map(&:to_h),
+        'observation' => observation
+      }
+    end
+
+    private
+
+    def candidates_for_receiver(site)
+      case site.receiver_kind
+      when :constant
+        exact = receiver_candidates(site).filter_map { |name| nodes["#{name}.#{site.message}"] }.first
+        exact ? [exact] : candidate_nodes(site.message)
+      when :instance
+        exact = receiver_candidates(site).filter_map { |name| nodes["#{name}##{site.message}"] }.first
+        exact ? [exact] : candidate_nodes(site.message)
+      when :self
+        same_owner_candidates(site)
+      when :implicit
+        same_owner_candidates(site).then { |matches| matches.empty? ? candidate_nodes(site.message) : matches }
+      else
+        candidate_nodes(site.message)
+      end
+    end
+
+    def same_owner_candidates(site)
+      caller = nodes[site.caller_id]
+      return [] unless caller&.owner
+
+      ids = [
+        "#{caller.owner}##{site.message}",
+        "#{caller.owner}.#{site.message}"
+      ]
+      ids.filter_map { |id| nodes[id] }
+    end
+
+    def receiver_candidates(site)
+      candidates = site.metadata['receiver_candidates'] || site.metadata[:receiver_candidates]
+      Array(candidates).compact.empty? ? [site.receiver_name].compact : Array(candidates).compact
+    end
+
+    def rta_candidate?(node, site)
+      return true unless node.kind == :instance_method
+      return true if node.owner == nodes[site.caller_id]&.owner
+      return true if class_info(node.owner)&.dynamic
+
+      instantiated_classes.include?(node.owner)
+    end
+
+    def ancestor_chain(owner)
+      chain = []
+      current = class_info(owner)&.superclass
+      while current && !chain.include?(current)
+        chain << current
+        current = class_info(current)&.superclass
+      end
+      chain
+    end
+
+    def merge_observation(left, right)
+      return right unless left.is_a?(Hash) && right.is_a?(Hash)
+
+      left.merge(right)
+    end
+
+    def retain_known_instantiated_classes
+      known_owners = method_nodes.map(&:owner).compact.to_set
+      instantiated_classes.select! { |name| known_owners.include?(name) }
+    end
+  end
+end

data/lib/necropsy/guardrail/baseline.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'time'
+
+module Necropsy
+  module Guardrail
+    class Baseline
+      attr_reader :path, :fingerprints
+
+      def self.load(path)
+        return new(path: path, fingerprints: []) unless File.exist?(path)
+
+        payload = YAML.load_file(path) || {}
+        new(path: path, fingerprints: Array(payload['findings']).map { |finding| finding['fingerprint'] })
+      end
+
+      def self.write(report, path:)
+        findings = report.findings.map do |finding|
+          {
+            'fingerprint' => finding.fingerprint,
+            'classification' => finding.classification.to_s,
+            'confidence' => finding.confidence.to_s,
+            'node_id' => finding.node.id,
+            'file' => finding.node.file,
+            'line' => finding.node.line
+          }
+        end
+        payload = {
+          'version' => 1,
+          'generated_at' => Time.now.utc.iso8601,
+          'findings' => findings
+        }
+        File.write(path, payload.to_yaml)
+      end
+
+      def initialize(path:, fingerprints:)
+        @path = path
+        @fingerprints = fingerprints
+      end
+
+      def include?(finding)
+        fingerprints.include?(finding.fingerprint)
+      end
+    end
+  end
+end

data/lib/necropsy/guardrail/diff.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Necropsy
+  module Guardrail
+    class Diff
+      def self.changed_files(root:, diff_base:)
+        stdout, status = Open3.capture2('git', '-C', root, 'diff', '--name-only', "#{diff_base}...HEAD")
+        return Set.new unless status.success?
+
+        stdout.lines.map(&:strip).reject(&:empty?).to_set
+      end
+    end
+  end
+end

data/lib/necropsy/guardrail/quarantine.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Necropsy
+  module Guardrail
+    class Quarantine
+      ANNOTATION_PREFIX = '# necropsy:quarantine'
+
+      def initialize(report:, root:)
+        @report = report
+        @root = root
+      end
+
+      def suggestions(min_confidence: :high)
+        report.dead_methods(min_confidence: min_confidence).map do |finding|
+          {
+            finding: finding,
+            annotation: "#{ANNOTATION_PREFIX} since=#{Date.today.iso8601}",
+            path: File.join(root, finding.node.file),
+            line: finding.node.line
+          }
+        end
+      end
+
+      def write(min_confidence: :high)
+        grouped = suggestions(min_confidence: min_confidence).group_by { |suggestion| suggestion[:path] }
+        grouped.each do |path, entries|
+          lines = File.readlines(path, chomp: true)
+          entries.sort_by { |entry| -entry[:line] }.each do |entry|
+            index = [entry[:line] - 1, 0].max
+            next if lines[index - 1]&.include?(ANNOTATION_PREFIX)
+
+            indent = lines[index][/^\s*/] || ''
+            lines.insert(index, "#{indent}#{entry[:annotation]}")
+          end
+          File.write(path, "#{lines.join("\n")}\n")
+        end
+      end
+
+      private
+
+      attr_reader :report, :root
+    end
+  end
+end

data/lib/necropsy/models.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Necropsy
+  Node = Data.define(:id, :kind, :file, :line, :end_line, :defined_via, :owner, :name, :test) do
+    def method?
+      kind != :block_entry
+    end
+
+    def fingerprint(classification)
+      Digest::SHA256.hexdigest("#{classification}:#{id}")
+    end
+
+    def to_h
+      {
+        'id' => id,
+        'kind' => kind.to_s,
+        'file' => file,
+        'line' => line,
+        'end_line' => end_line,
+        'defined_via' => defined_via.to_s,
+        'owner' => owner,
+        'name' => name,
+        'test' => test
+      }
+    end
+  end
+
+  Evidence = Data.define(:analyzer, :kind, :weight, :details, :metadata) do
+    def to_h
+      {
+        'analyzer' => analyzer.to_s,
+        'kind' => kind.to_s,
+        'weight' => weight,
+        'details' => details,
+        'metadata' => metadata
+      }
+    end
+  end
+
+  Edge = Data.define(:caller_id, :callee_id, :evidences) do
+    def to_h
+      {
+        'caller_id' => caller_id,
+        'callee_id' => callee_id,
+        'evidences' => evidences.map(&:to_h)
+      }
+    end
+  end
+
+  EntryPoint = Data.define(:node_id, :reason) do
+    def test?
+      reason == :test_suite
+    end
+
+    def to_h
+      { 'node_id' => node_id, 'reason' => reason.to_s }
+    end
+  end
+
+  ClassInfo = Data.define(
+    :id,
+    :kind,
+    :file,
+    :line,
+    :superclass,
+    :superclass_candidates,
+    :includes,
+    :prepends,
+    :extends,
+    :dynamic
+  ) do
+    def to_h
+      {
+        'id' => id,
+        'kind' => kind.to_s,
+        'file' => file,
+        'line' => line,
+        'superclass' => superclass,
+        'superclass_candidates' => superclass_candidates,
+        'includes' => includes,
+        'prepends' => prepends,
+        'extends' => extends,
+        'dynamic' => dynamic
+      }
+    end
+  end
+
+  CallSite = Data.define(
+    :caller_id,
+    :message,
+    :receiver_kind,
+    :receiver_name,
+    :file,
+    :line,
+    :test,
+    :dynamic,
+    :metadata
+  ) do
+    def to_h
+      {
+        'caller_id' => caller_id,
+        'message' => message,
+        'receiver_kind' => receiver_kind.to_s,
+        'receiver_name' => receiver_name,
+        'file' => file,
+        'line' => line,
+        'test' => test,
+        'dynamic' => dynamic,
+        'metadata' => metadata
+      }
+    end
+  end
+
+  AnalyzerProfile = Data.define(:name, :kind, :soundness, :description) do
+    def to_h
+      {
+        'name' => name.to_s,
+        'kind' => kind.to_s,
+        'soundness' => soundness.to_s,
+        'description' => description
+      }
+    end
+  end
+
+  EdgeEvidence = Data.define(:caller_id, :callee_id, :evidence)
+  AliveEvidence = Data.define(:node_id, :evidence)
+
+  AnalyzerResult = Data.define(:edge_evidences, :alive_evidences, :uncertainties, :observation) do
+    def self.empty
+      new(edge_evidences: [], alive_evidences: [], uncertainties: {}, observation: {})
+    end
+  end
+
+  Finding = Data.define(:node, :classification, :confidence, :score, :reasons, :evidences) do
+    LEVELS = {
+      low: 0,
+      medium: 1,
+      high: 2,
+      certain: 3
+    }.freeze
+
+    def at_least?(level)
+      LEVELS.fetch(confidence) >= LEVELS.fetch(level)
+    end
+
+    def fingerprint
+      node.fingerprint(classification)
+    end
+
+    def to_h
+      {
+        'fingerprint' => fingerprint,
+        'classification' => classification.to_s,
+        'confidence' => confidence.to_s,
+        'score' => score,
+        'node' => node.to_h,
+        'reasons' => reasons,
+        'evidences' => evidences.map(&:to_h)
+      }
+    end
+  end
+end

data/lib/necropsy/project.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Necropsy
+  class Project
+    EXCLUDED_DIRECTORIES = %w[
+      .bundle
+      .git
+      .serena
+      coverage
+      doc
+      node_modules
+      pkg
+      tmp
+      vendor
+    ].freeze
+
+    attr_reader :root, :config
+
+    def initialize(root:, config:)
+      @root = File.expand_path(root)
+      @config = config
+    end
+
+    def scan_result
+      @scan_result ||= Cache::ScanCache.new(project: self).fetch(ruby_files) do
+        AstScanner.new(project: self, files: ruby_files).scan
+      end
+    end
+
+    def ruby_files
+      @ruby_files ||= begin
+        globbed = Dir.glob(File.join(root, '**', '*.rb'))
+        special = %w[Rakefile].map { |name| File.join(root, name) }.select { |file| File.file?(file) }
+        rake = Dir.glob(File.join(root, '**', '*.rake'))
+        executables = Dir.glob(File.join(root, '{bin,exe}', '*')).select { |file| File.file?(file) }
+        gemspecs = Dir.glob(File.join(root, '*.gemspec'))
+        (globbed + special + rake + executables + gemspecs).uniq.select { |file| analyzable_file?(file) }.sort
+      end
+    end
+
+    def test_file?(file)
+      relative = relative_path(file)
+      relative.start_with?('spec/', 'test/')
+    end
+
+    def relative_path(file)
+      Pathname.new(File.expand_path(file)).relative_path_from(Pathname.new(root)).to_s
+    end
+
+    def changed_files(diff_base)
+      Guardrail::Diff.changed_files(root: root, diff_base: diff_base)
+    end
+
+    private
+
+    def analyzable_file?(file)
+      relative_parts = relative_path(file).split(File::SEPARATOR)
+      !relative_parts.intersect?(EXCLUDED_DIRECTORIES)
+    rescue ArgumentError
+      false
+    end
+  end
+end

data/lib/necropsy/reachability/engine.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Necropsy
+  module Reachability
+    Result = Data.define(:runtime_alive, :test_alive)
+
+    class Engine
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def call
+        runtime_roots = graph.entry_points.reject(&:test?).map(&:node_id)
+        test_roots = graph.entry_points.select(&:test?).map(&:node_id)
+
+        Result.new(
+          runtime_alive: traverse(runtime_roots),
+          test_alive: traverse(test_roots)
+        )
+      end
+
+      private
+
+      attr_reader :graph
+
+      def traverse(roots)
+        visited = Set.new
+        queue = roots.compact.uniq
+
+        until queue.empty?
+          node_id = queue.shift
+          next if visited.include?(node_id)
+
+          visited << node_id
+          graph.edges_from(node_id).each_key { |callee_id| queue << callee_id unless visited.include?(callee_id) }
+        end
+
+        visited
+      end
+    end
+  end
+end

data/lib/necropsy/report.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+
+module Necropsy
+  class Report
+    attr_reader :root, :graph, :findings
+
+    def initialize(root:, graph:, findings:)
+      @root = root
+      @graph = graph
+      @findings = findings
+    end
+
+    def dead_methods(min_confidence: :low)
+      findings.select { |finding| finding.at_least?(min_confidence) }
+    end
+
+    def to_h
+      {
+        'root' => root,
+        'summary' => summary,
+        'findings' => findings.map(&:to_h),
+        'graph' => graph.to_h
+      }
+    end
+
+    def to_json(*)
+      JSON.pretty_generate(to_h, *)
+    end
+
+    def to_yaml
+      to_h.to_yaml
+    end
+
+    def summary
+      grouped = findings.group_by(&:classification)
+      {
+        'nodes' => graph.nodes.length,
+        'edges' => graph.edges.length,
+        'entry_points' => graph.entry_points.length,
+        'findings' => findings.length,
+        'unreachable' => grouped.fetch(:unreachable, []).length,
+        'unused' => grouped.fetch(:unused, []).length,
+        'test_only_reachable' => grouped.fetch(:test_only_reachable, []).length
+      }
+    end
+  end
+end