audition 0.1.0 → 0.2.1

data/lib/audition/dynamic/prober.rb

@@ -201,21 +201,33 @@ module Audition
         findings
       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
+      # hard errors.
       def class_state_finding(entry, label)
         unshareable = entry.fetch("unshareable", [])
         hot = unshareable.any?
         detail =
           hot ? " (unshareable: #{unshareable.join(", ")})" : ""
+        why =
+          if hot
+            "Writes raise Ractor::IsolationError from non-main " \
+            "Ractors; reads raise too while the value is " \
+            "unshareable. #{RUNTIME_WHY}"
+          else
+            "Every value observed here is shareable, so reads " \
+            "from non-main Ractors are legal; only late writes " \
+            "would raise Ractor::IsolationError. #{RUNTIME_WHY}"
+          end
         runtime_finding(
           entry, label,
           check: "runtime-class-state",
-          severity: hot ? :error : :warning,
+          severity: hot ? :error : :info,
           message: "class-level state " \
                    "#{entry["ivars"].join(", ")} on " \
                    "#{entry["const"]}#{detail}",
-          why: "Writes raise Ractor::IsolationError from non-main " \
-               "Ractors; reads raise too while the value is " \
-               "unshareable. #{RUNTIME_WHY}",
+          why: why,
           fix: "Precompute and freeze at load, use " \
                "Ractor.store_if_absent, or keep per-Ractor state."
         )
@@ -322,8 +334,13 @@ module Audition
 
       # -- subprocess plumbing -------------------------------------
 
+      # Harness output can carry arbitrary target bytes; force
+      # valid UTF-8 before any string work or a binary exception
+      # message crashes the whole run.
       def run(mode, payload = {})
         out, err, timed_out = execute(mode, payload)
+        out = sanitize(out)
+        err = sanitize(err)
         if timed_out
           return {"error" => {
             "class" => "AuditionTimeout",
@@ -334,29 +351,68 @@ module Audition
       rescue JSON::ParserError
         {"error" => {
           "class" => "HarnessFailure",
-          "message" => (err || "").split("\n").last(5).join("; ")
+          "message" => err.split("\n").last(5).join("; ")
         }}
       end
 
+      def sanitize(text)
+        (text || "").dup.force_encoding(Encoding::UTF_8).scrub
+      end
+
+      # The harness leads its own process group so a timeout kills
+      # every descendant, and the pipe readers are bounded: a
+      # child the target spawned inherits our pipes and would
+      # otherwise hold the read until it exits, defeating the
+      # timeout and leaving orphans behind.
       def execute(mode, payload)
         cmd = [@ruby, "-W0", HARNESS, mode]
-        Open3.popen3(*cmd) do |stdin, stdout, stderr, wait|
+        Open3.popen3(*cmd, pgroup: true) do |stdin, stdout, stderr, wait|
           stdin.write(JSON.generate(payload))
           stdin.close
-          out_reader = Thread.new { stdout.read }
-          err_reader = Thread.new { stderr.read }
-          if wait.join(@timeout)
-            [out_reader.value, err_reader.value, false]
-          else
-            begin
-              Process.kill("KILL", wait.pid)
-            rescue Errno::ESRCH
-              nil
+          out_reader = reader(stdout)
+          err_reader = reader(stderr)
+          timed_out = wait.join(@timeout).nil?
+          kill_group(wait.pid) if timed_out
+          unless drain(out_reader, err_reader)
+            kill_group(wait.pid)
+            unless drain(out_reader, err_reader)
+              close_quietly(stdout)
+              close_quietly(stderr)
             end
-            [out_reader.value.to_s, err_reader.value.to_s, true]
           end
+          [out_reader.value.to_s, err_reader.value.to_s, timed_out]
         end
       end
+
+      # Accumulates chunks so a forced close still yields what
+      # arrived before it; a plain IO#read would lose everything.
+      def reader(io)
+        Thread.new do
+          buffer = String.new(encoding: Encoding::BINARY)
+          begin
+            loop { buffer << io.readpartial(65_536) }
+          rescue IOError
+            buffer
+          end
+          buffer
+        end
+      end
+
+      def drain(*threads)
+        threads.all? { |thread| thread.join(2) }
+      end
+
+      def kill_group(pid)
+        Process.kill("KILL", -pid)
+      rescue Errno::ESRCH, Errno::EPERM
+        nil
+      end
+
+      def close_quietly(io)
+        io.close
+      rescue IOError
+        nil
+      end
     end
   end
 end

data/lib/audition/fixer.rb

@@ -61,8 +61,12 @@ module Audition
         edits = build_edits(path, source, group)
         next if edits.empty?
 
-        Plan.new(path: path, source: source,
-          edits: edits.sort_by { |e| -e.start_offset })
+        # Applied bottom-up; the explicit index keeps same-offset
+        # inserts in plan order (sort_by is not stable).
+        ordered = edits.each_with_index.sort_by do |edit, index|
+          [-edit.start_offset, index]
+        end.map(&:first)
+        Plan.new(path: path, source: source, edits: ordered)
       end
     end
 
@@ -75,8 +79,10 @@ module Audition
         file = Static::SourceFile.new(source: source, path: path)
         if file.valid_syntax?
           magic = Rewriters::MagicComments.plan(file, group)
-          planned += Rewriters::Memoization.plan(file, group)
-          planned += Rewriters::WriteOnce.plan(file, group)
+          planned = Rewriters.resolve(
+            Rewriters::Memoization.plan(file, group) +
+            Rewriters::WriteOnce.plan(file, group)
+          )
         end
       end
 
@@ -105,37 +111,65 @@ module Audition
       accepted
     end
 
+    # Prism offsets are byte offsets; splicing must happen on a
+    # binary copy or every edit after the first multibyte
+    # character lands short (addressable's unicode tables were
+    # the crash test).
     def patched(plan)
-      source = plan.source.dup
+      encoding = plan.source.encoding
+      bytes = plan.source.dup.force_encoding(Encoding::BINARY)
       plan.edits.each do |edit|
-        source[edit.start_offset...edit.end_offset] =
-          edit.replacement
+        bytes[edit.start_offset...edit.end_offset] =
+          edit.replacement.dup.force_encoding(Encoding::BINARY)
       end
-      source
+      bytes.force_encoding(encoding)
     end
 
+    # Edits whose line windows overlap (a guard deletion runs into
+    # the write it pairs with) render as one hunk, so the preview
+    # never repeats a line in two half-applied states. All window
+    # math runs on a binary copy: the offsets are bytes.
     def hunks(plan)
-      plan.edits.sort_by(&:start_offset).map do |edit|
-        line_start =
-          if edit.start_offset.zero?
-            0
-          else
-            before = plan.source.rindex("\n", edit.start_offset - 1)
-            before ? before + 1 : 0
-          end
-        line_end = plan.source.index("\n", edit.end_offset) ||
-          plan.source.length
-        old = plan.source[line_start...line_end]
+      encoding = plan.source.encoding
+      raw = plan.source.dup.force_encoding(Encoding::BINARY)
+      groups = []
+      plan.edits.sort_by(&:start_offset).each do |edit|
+        from, upto = line_window(raw, edit)
+        if groups.any? && from <= groups.last[:upto]
+          last = groups.last
+          last[:upto] = [last[:upto], upto].max
+          last[:edits] << edit
+        else
+          groups << {from: from, upto: upto, edits: [edit]}
+        end
+      end
+      groups.map do |group|
+        old = raw[group[:from]...group[:upto]]
         updated = old.dup
-        span = ((edit.start_offset - line_start)...
-                (edit.end_offset - line_start))
-        updated[span] = edit.replacement
+        group[:edits].reverse_each do |edit|
+          span = ((edit.start_offset - group[:from])...
+                  (edit.end_offset - group[:from]))
+          updated[span] =
+            edit.replacement.dup.force_encoding(Encoding::BINARY)
+        end
         {
-          line: plan.source[0, edit.start_offset].count("\n") + 1,
-          old: old,
-          new: updated.chomp
+          line: raw[0, group[:from]].count("\n") + 1,
+          old: old.force_encoding(encoding),
+          new: updated.chomp.force_encoding(encoding)
         }
       end
     end
+
+    def line_window(raw, edit)
+      from =
+        if edit.start_offset.zero?
+          0
+        else
+          before = raw.rindex("\n", edit.start_offset - 1)
+          before ? before + 1 : 0
+        end
+      upto = raw.index("\n", edit.end_offset) || raw.length
+      [from, upto]
+    end
   end
 end

data/lib/audition/report.rb

@@ -34,12 +34,16 @@ module Audition
         @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|
+        define_method(name) do |text| # audition:disable unsafe-calls
           @pastel.public_send(name, text)
         end
       end
@@ -110,9 +114,10 @@ module Audition
       return :not_ready if own_errors?
       return :blocked if dependency_errors? ||
         dynamic_results.any? { |r| !r.passed }
-      return :risky if counts[:warning].positive? ||
-        counts[:info].positive?
+      return :risky if counts[:warning].positive?
 
+      # Info notes describe things that work on Ruby 4.0 and are
+      # only worth knowing; they do not taint the verdict.
       :ready
     end
 
@@ -134,7 +139,12 @@ module Audition
           else
             acc[f.severity] += 1
           end
-          acc[:fixable] += 1 if f.fixable?
+          # Only safe autofixes count: `--fix` alone would not
+          # touch an unsafe-only finding, so advertising it as
+          # fixable would send users in circles.
+          if f.autofix && !f.autofix.unsafe?
+            acc[:fixable] += 1
+          end
         end
       end
     end
@@ -159,8 +169,10 @@ module Audition
         level = GITHUB_LEVELS.fetch(f.severity)
         location = f.line ? ",line=#{f.line}" : ""
         body = workflow_escape("#{f.message}. #{f.why}")
-        "::#{level} file=#{f.path}#{location}," \
-        "title=audition #{f.check}::#{body}"
+        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")
@@ -207,6 +219,12 @@ module Audition
       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
@@ -275,8 +293,11 @@ module Audition
         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)/m)
+        text.scan(/\S.{0,#{width - 1}}(?=\s|\z)|\S{#{width}}/m)
       end
 
       def dynamic_section
@@ -297,16 +318,24 @@ module Audition
         [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 = []
-        parts << s.red("#{c[:error]} errors") if c[:error].positive?
+        if c[:error].positive?
+          parts << s.red(pluralize(c[:error], "error"))
+        end
         if c[:dep_error].positive?
-          parts << s.magenta("#{c[:dep_error]} dependency errors")
+          parts << s.magenta(
+            pluralize(c[:dep_error], "dependency error")
+          )
         end
         if c[:warning].positive?
-          parts << s.yellow("#{c[:warning]} warnings")
+          parts << s.yellow(pluralize(c[:warning], "warning"))
         end
         parts << s.cyan("#{c[:info]} info") if c[:info].positive?
         if c[:fixable].positive?
@@ -317,7 +346,8 @@ module Audition
         end
         if @report.unsafe_fixes.positive?
           parts << s.cyan(
-            "#{@report.unsafe_fixes} more with --fix-unsafe"
+            pluralize(@report.unsafe_fixes, "edit") +
+            " with --fix-unsafe"
           )
         end
         if @report.baselined.positive?