audition 0.2.4 → 0.4.0

data/lib/audition/report/sweep.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "json"
+require "table_tennis"
+
+module Audition
+  class Report
+    # Renders a bundle sweep. Its unit is a gem rather than a
+    # finding, so it gets its own renderer instead of bending
+    # Report around a shape it does not have.
+    class Sweep
+      CELLS = {
+        :not_ready => "not ready", :blocked => "blocked",
+        :risky => "risky", :ready => "ready", nil => "-"
+      }.freeze
+
+      # The severity glyphs the text report uses, so a verdict
+      # reads the same in a cell as it does in a summary.
+      GLYPHS = {
+        not_ready: :error, blocked: :warning,
+        risky: :warning, ready: :pass
+      }.freeze
+
+      # Foreground only, and applied to the whole row: a
+      # background fill reads as a bar across the table, and a
+      # painted cell would widen its column by the invisible
+      # length of its own escape sequence. Ready gems keep the
+      # default color, so what is colored is what needs reading.
+      PAINTS = Ractor.make_shareable({
+        :not_ready => [:red], :blocked => [:magenta],
+        :risky => [:yellow], nil => [:faint]
+      })
+
+      TITLE = "Audition bundle sweep"
+
+      # @param rows [Array<BundleSweep::Row>] one per locked gem
+      # @param style [Style] palette for the text rendering
+      def initialize(rows, style)
+        @rows = rows
+        @style = style
+      end
+
+      # @param table_opts [Hash] what the terminal supports; see
+      #   the caller for why color cannot be detected here
+      # @return [String] the table plus a summary line
+      def render(**table_opts)
+        table = TableTennis.new(cells, title: TITLE, mark: paint,
+          **table_opts)
+        "#{table}\n#{summary}"
+      end
+
+      def json
+        JSON.pretty_generate(
+          "audition" => VERSION,
+          "ruby" => RUBY_VERSION,
+          "bundle" => @rows.map { |r| json_row(r) }
+        )
+      end
+
+      # Sweep rows carry no file or line, so annotations land on
+      # the run summary rather than a diff.
+      # @return [String] annotation lines plus a summary line
+      def annotations
+        lines = @rows.filter_map do |row|
+          level = annotation_level(row)
+          next unless level
+
+          "::#{level} title=Audition::gem #{row.name} " \
+          "#{row.version}: #{row.errors} errors, " \
+          "#{row.dep_errors} dependency errors, " \
+          "#{row.warnings} warnings (#{CELLS.fetch(row.verdict)})"
+        end
+        (lines << plain_summary).join("\n")
+      end
+
+      # @return [String] job summary page table for Actions
+      def markdown
+        lines = [
+          "## #{TITLE}", "",
+          "| gem | version | verdict | errors | dep errors " \
+          "| warnings | fixable |",
+          "| --- | --- | --- | --- | --- | --- | --- |"
+        ]
+        @rows.each do |r|
+          lines << "| #{r.name} | #{r.version} | " \
+            "#{CELLS.fetch(r.verdict)} | #{r.errors} | " \
+            "#{r.dep_errors} | #{r.warnings} | #{r.fixable} |"
+        end
+        lines.push("", plain_summary).join("\n")
+      end
+
+      private
+
+      def cells
+        @rows.map do |r|
+          {
+            "gem" => r.name,
+            "version" => r.version,
+            "verdict" => verdict_cell(r.verdict),
+            "errors" => clean_as_blank(r.errors),
+            "dep errors" => clean_as_blank(r.dep_errors),
+            "warnings" => clean_as_blank(r.warnings),
+            "fixable" => clean_as_blank(r.fixable),
+            "status" => r.status
+          }
+        end
+      end
+
+      def verdict_cell(verdict)
+        cell = CELLS.fetch(verdict)
+        glyph = GLYPHS[verdict]
+        glyph ? "#{@style.glyph(glyph)} #{cell}" : cell
+      end
+
+      # A clean count is the common case across hundreds of gems;
+      # leaving it to the table's placeholder keeps the eye on the
+      # rows that carry something.
+      def clean_as_blank(count)
+        count.positive? ? count : nil
+      end
+
+      # The table gem hands the lambda back the row it was given,
+      # which carries the gem but not the verdict symbol.
+      def paint
+        paints = @rows.to_h do |r|
+          [[r.name, r.version], PAINTS[r.verdict]]
+        end
+        ->(row) { paints[[row["gem"], row["version"]]] }
+      end
+
+      def summary
+        glyph, paint = if blockers.positive?
+          [:error, :red]
+        elsif ready == @rows.size
+          [:pass, :green]
+        else
+          [:warning, :yellow]
+        end
+        head = @style.public_send(paint,
+          "#{@style.glyph(glyph)} #{plain_summary}")
+        return head if blockers.zero?
+
+        "#{head} #{@style.dim("· #{blockers} not ready")}"
+      end
+
+      def plain_summary
+        "#{ready} of #{@rows.size} gems ractor-ready"
+      end
+
+      def ready
+        @ready ||= @rows.count { |r| r.verdict == :ready }
+      end
+
+      def blockers
+        @blockers ||= @rows.count { |r| r.verdict == :not_ready }
+      end
+
+      def annotation_level(row)
+        if row.verdict == :not_ready ||
+            (row.errors + row.dep_errors).positive?
+          "error"
+        elsif row.warnings.positive?
+          "warning"
+        end
+      end
+
+      def json_row(row)
+        {
+          "gem" => row.name,
+          "version" => row.version,
+          "verdict" => row.verdict&.to_s,
+          "errors" => row.errors,
+          "dependency_errors" => row.dep_errors,
+          "warnings" => row.warnings,
+          "infos" => row.infos,
+          "fixable" => row.fixable,
+          "status" => row.status
+        }
+      end
+    end
+  end
+end

data/lib/audition/report/text.rb

@@ -0,0 +1,160 @@
+# 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)")}" : ""
+        test_mark = finding.test? ? " #{s.dim("(tests)")}" : ""
+        head = "    #{glyph} #{loc}#{finding.message}" \
+               "#{fix_mark}#{dep_mark}#{test_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?
+        test_total = c[:test_error] + c[:test_warning] +
+          c[:test_info]
+        if test_total.positive?
+          parts << s.dim(
+            pluralize(test_total, "test finding") +
+            " (#{c[:test_error]} error / " \
+            "#{c[:test_warning]} warning / #{c[:test_info]} info)"
+          )
+        end
+        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

data/lib/audition/report.rb

@@ -1,84 +1,15 @@
 # frozen_string_literal: true
 
-require "json"
-require "pastel"
-require "tty/link"
-
 module Audition
-  # Aggregates static findings and dynamic results into a verdict and
-  # renders them as npm-CLI-style text or JSON.
+  # Aggregates static findings and dynamic results into a verdict
+  # and the counts the renderers work from. Rendering lives in the
+  # Report::Text, Report::Json, and Report::Github classes.
   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
-
     VERDICTS = {
       not_ready: "not ractor-ready",
       blocked: "own code is ractor-ready; blocked by dependencies",
       risky: "risky: warnings only, no hard errors",
-      ready: "ractor-ready as far as audition can tell"
+      ready: "ractor-ready as far as Audition can tell"
     }.freeze
 
     attr_reader :target_type, :target_root, :findings,
@@ -129,13 +60,19 @@ module Audition
       counts[:dep_error].positive?
     end
 
+    # Test findings count apart at every severity: they are the
+    # target's code, but a production boot never loads them, so
+    # they never touch the verdict.
     def counts
       @counts ||= begin
         base = {error: 0, dep_error: 0, warning: 0, info: 0,
+                test_error: 0, test_warning: 0, test_info: 0,
                 fixable: 0}
         findings.each_with_object(base) do |f, acc|
           if f.error? && f.dependency?
             acc[:dep_error] += 1
+          elsif f.test?
+            acc[:"test_#{f.severity}"] += 1
           else
             acc[f.severity] += 1
           end
@@ -148,227 +85,11 @@ module Audition
         end
       end
     end
-
-    # @param style [Style] rendering style (auto-detected default)
-    # @return [String] the human-facing terminal report
-    def to_text(style: Style.detect)
-      Text.new(self, style).render
-    end
-
-    GITHUB_LEVELS = {
-      error: "error", warning: "warning", info: "notice"
-    }.freeze
-
-    # GitHub Actions workflow commands: findings become inline PR
-    # annotations when this runs in CI.
-    #
-    # @return [String] one `::error`/`::warning`/`::notice` line
-    #   per finding plus a verdict line
-    def to_github
-      lines = findings.map do |f|
-        level = GITHUB_LEVELS.fetch(f.severity)
-        location = f.line ? ",line=#{f.line}" : ""
-        body = workflow_escape("#{f.message}. #{f.why}")
-        file = property_escape(f.path)
-        title = property_escape("audition #{f.check}")
-        "::#{level} file=#{file}#{location}," \
-        "title=#{title}::#{body}"
-      end
-      lines << "audition verdict: #{VERDICTS.fetch(verdict)}"
-      lines.join("\n")
-    end
-
-    def to_json(*)
-      JSON.pretty_generate(
-        "audition" => VERSION,
-        "ruby" => RUBY_VERSION,
-        "target" => {"type" => target_type.to_s,
-                     "root" => target_root},
-        "verdict" => verdict.to_s,
-        "summary" => {
-          "errors" => counts[:error],
-          "dependency_errors" => counts[:dep_error],
-          "warnings" => counts[:warning],
-          "infos" => counts[:info],
-          "fixable" => counts[:fixable]
-        },
-        "findings" => 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,
-        "dynamic" => dynamic_results.map do |r|
-          {"mode" => r.mode.to_s, "passed" => r.passed,
-           "raw" => r.raw}
-        end
-      )
-    end
-
-    private
-
-    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
-
-    public
-
-    # Text renderer, kept separate from the data so styles stay
-    # injectable.
-    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
+
+require_relative "report/style"
+require_relative "report/text"
+require_relative "report/json"
+require_relative "report/github"
+require_relative "report/sweep"