audition 0.2.4 → 0.3.0

data/lib/audition/dynamic/prober.rb

@@ -38,7 +38,10 @@ module Audition
 
       # Runs the probe described by a {Target#entry} hash.
       #
-      # @param entry [Hash] `:mode` plus mode-specific keys
+      # @param entry [Hash] `:mode` plus mode-specific keys; require
+      #   and rails entries may carry `:compiled_files`, the target's
+      #   own compiled extensions, which the static check already
+      #   covers and the probe therefore does not report again
       # @return [Result]
       # @raise [Audition::Error] on an unknown mode
       def probe(entry)
@@ -104,7 +107,8 @@ module Audition
         raw = run("require",
           "feature" => feature,
           "load_paths" => Array(entry[:load_paths]),
-          "root" => entry[:root])
+          "root" => entry[:root],
+          "known_compiled" => Array(entry[:compiled_files]))
         findings = runtime_findings(raw, feature)
         Result.new(mode: :require, raw: raw, findings: findings,
           passed: own_clean?(findings))
@@ -113,7 +117,8 @@ module Audition
       def probe_rails(entry)
         raw = run("rails",
           "environment" => entry[:environment],
-          "root" => entry[:root])
+          "root" => entry[:root],
+          "known_compiled" => Array(entry[:compiled_files]))
         boot = raw["boot"]
         if boot && !boot["ok"]
           finding = Finding.new(
@@ -198,9 +203,45 @@ module Audition
                  "or Ractor-local storage."
           )
         end
+        raw.fetch("native_extensions", []).each do |entry|
+          next if entry["ruby"] || entry["known"]
+
+          findings << native_finding(entry, label)
+        end
         findings
       end
 
+      # Ruby's own extensions are left to Ruby, and files the static
+      # check already reported are not repeated; what remains is the
+      # native code the target pulls in through its dependencies.
+      def native_finding(entry, label)
+        name = File.basename(entry["path"])
+        native = Static::NativeExtensions
+        if entry["declares"]
+          runtime_finding(
+            entry, label,
+            check: "runtime-native-extension",
+            severity: :info,
+            message: "compiled extension #{name} declares Ractor " \
+                     "safety (imports #{native::SYMBOL})",
+            why: "#{native::DECLARED_WHY} Loaded while requiring " \
+                 "the target.",
+            fix: native::DECLARED_FIX
+          )
+        else
+          runtime_finding(
+            entry, label,
+            check: "runtime-native-extension",
+            severity: :warning,
+            message: "compiled extension #{name} does not declare " \
+                     "Ractor safety",
+            why: "#{native::SILENT_WHY}#{native::COMPILED_TAIL} " \
+                 "Loaded while requiring the target.",
+            fix: native::SILENT_FIX
+          )
+        end
+      end
+
       # Class-level state holding only shareable values is the
       # warmed frozen-memoization shape: reads are legal from any
       # Ractor, so it rates an info note; unshareable values are

data/lib/audition/report/github.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Audition
+  class Report
+    # GitHub Actions renderer: workflow-command annotations that
+    # land on the PR diff, plus a markdown table for the job
+    # summary page ($GITHUB_STEP_SUMMARY).
+    class Github
+      LEVELS = {
+        error: "error", warning: "warning", info: "notice"
+      }.freeze
+
+      def initialize(report)
+        @report = report
+      end
+
+      # @return [String] one `::error`/`::warning`/`::notice` line
+      #   per finding plus a verdict line
+      def render
+        lines = @report.findings.map { |f| annotation(f) }
+        lines <<
+          "audition verdict: #{VERDICTS.fetch(@report.verdict)}"
+        lines.join("\n")
+      end
+
+      # @return [String] verdict heading plus a counts table
+      def summary
+        c = @report.counts
+        <<~MARKDOWN
+          ## audition: #{VERDICTS.fetch(@report.verdict)}
+
+          | findings | count |
+          | --- | --- |
+          | errors | #{c[:error]} |
+          | dependency errors | #{c[:dep_error]} |
+          | warnings | #{c[:warning]} |
+          | info | #{c[:info]} |
+          | fixable | #{c[:fixable]} |
+        MARKDOWN
+      end
+
+      private
+
+      def annotation(f)
+        level = LEVELS.fetch(f.severity)
+        location = f.line ? ",line=#{f.line}" : ""
+        body = workflow_escape("#{f.message}. #{f.why}")
+        # Annotations anchor to workspace-relative paths; a `./`
+        # prefix (from `audition .`) keeps them off the diff.
+        file = property_escape(f.path.delete_prefix("./"))
+        title = property_escape("audition #{f.check}")
+        "::#{level} file=#{file}#{location}," \
+        "title=#{title}::#{body}"
+      end
+
+      def workflow_escape(text)
+        text.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+      end
+
+      # Workflow command properties additionally reserve `:` and
+      # `,`; an unescaped comma in a path would end the property
+      # early.
+      def property_escape(text)
+        workflow_escape(text).gsub(":", "%3A").gsub(",", "%2C")
+      end
+    end
+  end
+end

data/lib/audition/report/json.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Audition
+  class Report
+    # Machine-readable renderer for CI pipelines and --compare.
+    class Json
+      def initialize(report)
+        @report = report
+      end
+
+      def render
+        JSON.pretty_generate(
+          "audition" => VERSION,
+          "ruby" => RUBY_VERSION,
+          "target" => {"type" => @report.target_type.to_s,
+                       "root" => @report.target_root},
+          "verdict" => @report.verdict.to_s,
+          "summary" => summary,
+          "findings" => findings,
+          "dynamic" => dynamic
+        )
+      end
+
+      private
+
+      def summary
+        counts = @report.counts
+        {
+          "errors" => counts[:error],
+          "dependency_errors" => counts[:dep_error],
+          "warnings" => counts[:warning],
+          "infos" => counts[:info],
+          "fixable" => counts[:fixable]
+        }
+      end
+
+      def findings
+        @report.findings.map do |f|
+          {
+            "check" => f.check,
+            "severity" => f.severity.to_s,
+            "message" => f.message,
+            "why" => f.why,
+            "fix" => f.fix,
+            "path" => f.path,
+            "line" => f.line,
+            "source" => f.source,
+            "fixable" => f.fixable?,
+            "dependency" => f.dependency?
+          }
+        end
+      end
+
+      def dynamic
+        @report.dynamic_results.map do |r|
+          {"mode" => r.mode.to_s, "passed" => r.passed,
+           "raw" => r.raw}
+        end
+      end
+    end
+  end
+end

data/lib/audition/report/style.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty/link"
+
+module Audition
+  class Report
+    # ANSI + OSC 8 styling with graceful degradation. Color and
+    # hyperlinks are decided once, at construction; pass color: false
+    # for pipes, NO_COLOR, or dumb terminals.
+    class Style
+      GLYPHS = Ractor.make_shareable(
+        {
+          error: ["✖", "x"], warning: ["⚠", "!"],
+          info: ["ℹ", "i"], pass: ["✔", "ok"],
+          section: ["◆", "*"], fix: ["✎", "+"]
+        }
+      )
+
+      PAINTS = %i[red yellow green cyan magenta dim bold].freeze
+
+      def self.detect(io: $stdout)
+        on = io.respond_to?(:tty?) && io.tty? &&
+          !ENV.key?("NO_COLOR") && ENV["TERM"] != "dumb"
+        new(color: on, hyperlinks: on && TTY::Link.link?)
+      end
+
+      def initialize(color:, hyperlinks:)
+        @pastel = Pastel.new(enabled: color)
+        @color = color
+        @hyperlinks = hyperlinks
+      end
+
+      def color?
+        @color
+      end
+
+      def glyph(kind)
+        GLYPHS.fetch(kind)[@color ? 0 : 1]
+      end
+
+      PAINTS.each do |name|
+        define_method(name) do |text| # audition:disable unsafe-calls
+          @pastel.public_send(name, text)
+        end
+      end
+
+      def severity_color(severity, text)
+        case severity
+        when :error then red(text)
+        when :warning then yellow(text)
+        else cyan(text)
+        end
+      end
+
+      # OSC 8 hyperlink wrapping "path:line" display text in a
+      # file:// URI; supporting terminals make it clickable.
+      # tty-link emits when it detects support; when hyperlinks are
+      # forced on despite no detection (tests, --force scenarios)
+      # fall back to the raw OSC 8 template, since tty-link's
+      # fallback is "text -> url" prose.
+      def link(text, absolute_path)
+        return text unless @hyperlinks
+
+        uri = "file://#{absolute_path}"
+        if TTY::Link.link?
+          TTY::Link.link_to(text, uri)
+        else
+          "\e]8;;#{uri}\e\\#{text}\e]8;;\e\\"
+        end
+      end
+    end
+  end
+end

data/lib/audition/report/text.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Audition
+  class Report
+    # Terminal renderer; styles stay injectable so pipes and
+    # --plain degrade cleanly.
+    class Text
+      WRAP = 74
+
+      def initialize(report, style)
+        @report = report
+        @style = style
+      end
+
+      def render
+        [header, *file_sections, *dynamic_section, summary]
+          .join("\n")
+      end
+
+      private
+
+      def header
+        s = @style
+        title = s.bold("audition #{VERSION}")
+        meta = s.dim(
+          "ruby #{RUBY_VERSION} · #{@report.target_type} at " \
+          "#{@report.target_root}"
+        )
+        "#{s.glyph(:section)} #{title} #{meta}\n"
+      end
+
+      def file_sections
+        @report.findings.group_by(&:path).map do |path, findings|
+          lines = [@style.bold("  #{path}")]
+          findings.each { |f| lines.concat(finding_lines(f)) }
+          lines.join("\n") + "\n"
+        end
+      end
+
+      def finding_lines(finding)
+        s = @style
+        glyph = s.severity_color(finding.severity,
+          s.glyph(finding.severity))
+        loc = location_label(finding)
+        fix_mark = finding.fixable? ? " #{s.cyan(s.glyph(:fix))}" : ""
+        dep_mark =
+          finding.dependency? ? " #{s.dim("(dependency)")}" : ""
+        head = "    #{glyph} #{loc}#{finding.message}" \
+               "#{fix_mark}#{dep_mark} #{s.dim(finding.check)}"
+        [head,
+          *annotation("why", finding.why),
+          *annotation("fix", finding.fix)]
+      end
+
+      def location_label(finding)
+        return "" unless finding.line
+
+        s = @style
+        text = "#{finding.path}:#{finding.line}"
+        absolute = File.expand_path(finding.path, @report.target_root)
+        "#{s.cyan(s.link(text, absolute))}  "
+      end
+
+      def annotation(label, content)
+        return [] if content.nil? || content.empty?
+
+        wrapped = wrap("#{label}: #{content}", WRAP - 6)
+        wrapped.map { |line| "      #{@style.dim(line)}" }
+      end
+
+      # Tokens longer than the width (long URLs) cannot end before
+      # whitespace, so the first alternative would drop their head;
+      # the second hard-slices them instead.
+      def wrap(text, width)
+        text.scan(/\S.{0,#{width - 1}}(?=\s|\z)|\S{#{width}}/m)
+      end
+
+      def dynamic_section
+        return [] if @report.dynamic_results.empty?
+
+        s = @style
+        lines = [s.bold("  dynamic probes")]
+        @report.dynamic_results.each do |result|
+          lines << if result.passed
+            "    #{s.green(s.glyph(:pass))} " \
+            "#{result.mode} probe passed inside a Ractor"
+          else
+            "    #{s.red(s.glyph(:error))} " \
+            "#{result.mode} probe failed " \
+            "#{s.dim("(details above)")}"
+          end
+        end
+        [lines.join("\n") + "\n"]
+      end
+
+      def pluralize(count, noun)
+        (count == 1) ? "#{count} #{noun}" : "#{count} #{noun}s"
+      end
+
+      def summary
+        s = @style
+        c = @report.counts
+        parts = []
+        if c[:error].positive?
+          parts << s.red(pluralize(c[:error], "error"))
+        end
+        if c[:dep_error].positive?
+          parts << s.magenta(
+            pluralize(c[:dep_error], "dependency error")
+          )
+        end
+        if c[:warning].positive?
+          parts << s.yellow(pluralize(c[:warning], "warning"))
+        end
+        parts << s.cyan("#{c[:info]} info") if c[:info].positive?
+        if c[:fixable].positive?
+          parts << s.cyan(
+            "#{c[:fixable]} fixable #{s.glyph(:fix)} " \
+            "(run with --fix)"
+          )
+        end
+        if @report.unsafe_fixes.positive?
+          parts << s.cyan(
+            pluralize(@report.unsafe_fixes, "edit") +
+            " with --fix-unsafe"
+          )
+        end
+        if @report.baselined.positive?
+          parts << s.dim("#{@report.baselined} baselined")
+        end
+        parts << s.green("no findings") if parts.empty?
+
+        verdict = @report.verdict
+        glyph, paint =
+          case verdict
+          when :not_ready then [:error, :red]
+          when :blocked then [:warning, :magenta]
+          when :risky then [:warning, :yellow]
+          else [:pass, :green]
+          end
+        badge = s.public_send(paint,
+          "#{s.glyph(glyph)} " +
+          VERDICTS.fetch(verdict))
+        "  summary: #{parts.join(" · ")}\n" \
+        "  verdict: #{s.bold(badge)}\n"
+      end
+    end
+  end
+end