necropsy 0.1.0

data/lib/necropsy/reporter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class Reporter
+    def initialize(report)
+      @report = report
+    end
+
+    def render(format: :human, min_confidence: :low)
+      case format.to_sym
+      when :json
+        report.to_json
+      when :sarif
+        render_sarif(min_confidence)
+      when :github, :annotations
+        render_github_annotations(min_confidence)
+      when :yaml, :yml
+        report.to_yaml
+      else
+        render_human(min_confidence)
+      end
+    end
+
+    private
+
+    attr_reader :report
+
+    def render_human(min_confidence)
+      findings = report.dead_methods(min_confidence: min_confidence)
+      lines = [
+        'Necropsy report',
+        "Root: #{report.root}",
+        "Nodes: #{report.summary['nodes']}, Edges: #{report.summary['edges']}, Entry points: #{report.summary['entry_points']}",
+        "Findings: #{findings.length}"
+      ]
+
+      findings.group_by(&:classification).sort_by do |classification, _|
+        classification.to_s
+      end.each do |classification, group|
+        lines << ''
+        lines << "#{classification} (#{group.length})"
+        group.sort_by { |finding| [finding.node.file, finding.node.line, finding.node.id] }.each do |finding|
+          lines << "  [#{finding.confidence}] #{finding.node.id} #{finding.node.file}:#{finding.node.line}"
+        end
+      end
+
+      lines.join("\n")
+    end
+
+    def render_github_annotations(min_confidence)
+      report.dead_methods(min_confidence: min_confidence).map do |finding|
+        message = "#{finding.classification} #{finding.node.id} confidence=#{finding.confidence}"
+        escaped = message.gsub('%', '%25').gsub("\n", '%0A').gsub("\r", '%0D')
+        "::warning file=#{finding.node.file},line=#{finding.node.line},title=Necropsy #{finding.confidence}::#{escaped}"
+      end.join("\n")
+    end
+
+    def render_sarif(min_confidence)
+      findings = report.dead_methods(min_confidence: min_confidence)
+      {
+        'version' => '2.1.0',
+        '$schema' => 'https://json.schemastore.org/sarif-2.1.0.json',
+        'runs' => [
+          {
+            'tool' => {
+              'driver' => {
+                'name' => 'Necropsy',
+                'informationUri' => 'https://github.com/ydah/necropsy',
+                'rules' => sarif_rules(findings)
+              }
+            },
+            'results' => findings.map { |finding| sarif_result(finding) }
+          }
+        ]
+      }.to_json
+    end
+
+    def sarif_rules(findings)
+      findings.map(&:classification).uniq.map do |classification|
+        {
+          'id' => classification.to_s,
+          'name' => classification.to_s,
+          'shortDescription' => { 'text' => "Necropsy #{classification}" }
+        }
+      end
+    end
+
+    def sarif_result(finding)
+      {
+        'ruleId' => finding.classification.to_s,
+        'level' => sarif_level(finding),
+        'message' => { 'text' => "#{finding.node.id} is #{finding.classification} (#{finding.confidence})" },
+        'locations' => [
+          {
+            'physicalLocation' => {
+              'artifactLocation' => { 'uri' => finding.node.file },
+              'region' => { 'startLine' => finding.node.line }
+            }
+          }
+        ],
+        'partialFingerprints' => { 'necropsy' => finding.fingerprint }
+      }
+    end
+
+    def sarif_level(finding)
+      return 'error' if %i[certain high].include?(finding.confidence)
+      return 'warning' if finding.confidence == :medium
+
+      'note'
+    end
+  end
+end

data/lib/necropsy/runner.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Necropsy
+  class Runner
+    attr_reader :root, :config, :analyzers
+
+    def initialize(root:, config_path: nil, analyzers: nil)
+      @root = File.expand_path(root)
+      @config = Configuration.load(root: @root, path: config_path)
+      @analyzers = analyzers
+    end
+
+    def analyze
+      project = Project.new(root: root, config: config)
+      graph = CallGraph.new(project.scan_result)
+
+      apply_entry_points(graph, project)
+      configured_analyzers.each do |analyzer|
+        graph.add_profile(analyzer.profile)
+        graph.apply_result(analyzer.analyze(graph, project))
+      end
+
+      reachability = Reachability::Engine.new(graph).call
+      findings = Confidence::Scorer.new(graph: graph, reachability: reachability, project: project).findings
+      Report.new(root: root, graph: graph, findings: findings)
+    end
+
+    private
+
+    def apply_entry_points(graph, project)
+      EntryPoints::Plain.new.apply(graph, project)
+      EntryPoints::Rails.new.apply(graph, project)
+      EntryPoints::Test.new.apply(graph, project)
+      graph.entrypoint_hints.each { |entry| graph.add_entry_point(entry.node_id, entry.reason) }
+    end
+
+    def configured_analyzers
+      return analyzers if analyzers
+
+      static = config.static_analyzers.filter_map do |name|
+        case name
+        when 'name_resolution'
+          Analyzers::Static::NameResolution.new
+        when 'cha'
+          Analyzers::Static::CHA.new
+        when 'rta'
+          Analyzers::Static::RTA.new
+        end
+      end
+
+      dynamic = []
+      coverage_config = config.dynamic_config(:coverage)
+      dynamic << Analyzers::Dynamic::CoverageImporter.new(coverage_config) if coverage_config['source']
+      coverband_config = config.dynamic_config(:coverband)
+      dynamic << Analyzers::Dynamic::CoverbandImporter.new(coverband_config) if coverband_config['source']
+      trace_point_config = config.dynamic_config(:trace_point)
+      dynamic << Analyzers::Dynamic::TracePointImporter.new(trace_point_config) if trace_point_config['source']
+
+      static + dynamic + custom_analyzers
+    end
+
+    def custom_analyzers
+      config.custom_analyzers.map do |class_name|
+        constantize(class_name).new
+      rescue NameError => e
+        raise Error, "Could not load custom analyzer #{class_name}: #{e.message}"
+      end
+    end
+
+    def constantize(class_name)
+      class_name.split('::').reduce(Object) { |constant, name| constant.const_get(name) }
+    end
+  end
+end

data/lib/necropsy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Necropsy
+  VERSION = '0.1.0'
+end

data/lib/necropsy.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'necropsy/version'
+require_relative 'necropsy/models'
+require_relative 'necropsy/configuration'
+require_relative 'necropsy/ast_scanner'
+require_relative 'necropsy/cache/scan_cache'
+require_relative 'necropsy/project'
+require_relative 'necropsy/graph/call_graph'
+require_relative 'necropsy/analyzer'
+require_relative 'necropsy/analyzers/static/name_resolution'
+require_relative 'necropsy/analyzers/static/cha'
+require_relative 'necropsy/analyzers/static/rta'
+require_relative 'necropsy/analyzers/dynamic/coverage_importer'
+require_relative 'necropsy/analyzers/dynamic/coverage_collector'
+require_relative 'necropsy/analyzers/dynamic/coverband_importer'
+require_relative 'necropsy/analyzers/dynamic/trace_point_importer'
+require_relative 'necropsy/analyzers/dynamic/trace_point_collector'
+require_relative 'necropsy/entry_points/plain'
+require_relative 'necropsy/entry_points/rails'
+require_relative 'necropsy/entry_points/test'
+require_relative 'necropsy/reachability/engine'
+require_relative 'necropsy/confidence/scorer'
+require_relative 'necropsy/report'
+require_relative 'necropsy/reporter'
+require_relative 'necropsy/guardrail/baseline'
+require_relative 'necropsy/guardrail/diff'
+require_relative 'necropsy/guardrail/quarantine'
+require_relative 'necropsy/bench/evaluator'
+require_relative 'necropsy/runner'
+
+module Necropsy
+  class Error < StandardError; end
+
+  def self.analyze(root: '.', config_path: nil, analyzers: nil)
+    Runner.new(root: root, config_path: config_path, analyzers: analyzers).analyze
+  end
+
+  def self.default_analyzers
+    [
+      Analyzers::Static::NameResolution.new,
+      Analyzers::Static::CHA.new,
+      Analyzers::Static::RTA.new
+    ]
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: necropsy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 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: Necropsy combines static call-graph reachability, optional dynamic evidence,
+  and CI guardrails for Ruby dead-code detection.
+email:
+- t.yudai92@gmail.com
+executables:
+- necropsy
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/necropsy
+- lib/necropsy.rb
+- lib/necropsy/analyzer.rb
+- lib/necropsy/analyzers/dynamic/coverage_collector.rb
+- lib/necropsy/analyzers/dynamic/coverage_importer.rb
+- lib/necropsy/analyzers/dynamic/coverband_importer.rb
+- lib/necropsy/analyzers/dynamic/trace_point_collector.rb
+- lib/necropsy/analyzers/dynamic/trace_point_importer.rb
+- lib/necropsy/analyzers/static/cha.rb
+- lib/necropsy/analyzers/static/name_resolution.rb
+- lib/necropsy/analyzers/static/rta.rb
+- lib/necropsy/ast_scanner.rb
+- lib/necropsy/bench/evaluator.rb
+- lib/necropsy/cache/scan_cache.rb
+- lib/necropsy/cli.rb
+- lib/necropsy/confidence/scorer.rb
+- lib/necropsy/configuration.rb
+- lib/necropsy/coverage_runtime.rb
+- lib/necropsy/entry_points/plain.rb
+- lib/necropsy/entry_points/rails.rb
+- lib/necropsy/entry_points/test.rb
+- lib/necropsy/graph/call_graph.rb
+- lib/necropsy/guardrail/baseline.rb
+- lib/necropsy/guardrail/diff.rb
+- lib/necropsy/guardrail/quarantine.rb
+- lib/necropsy/models.rb
+- lib/necropsy/project.rb
+- lib/necropsy/reachability/engine.rb
+- lib/necropsy/report.rb
+- lib/necropsy/reporter.rb
+- lib/necropsy/runner.rb
+- lib/necropsy/version.rb
+homepage: https://github.com/ydah/necropsy
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ydah/necropsy
+  source_code_uri: https://github.com/ydah/necropsy.git
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Hybrid dead-code detection for Ruby projects.
+test_files: []