jitcatch 0.1.0

data/lib/jitcatch/git_repo.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module JitCatch
+  # Thin git wrapper. Every invocation is an argv array, never a shell.
+  class GitRepo
+    attr_reader :dir
+
+    def initialize(path)
+      @dir = File.expand_path(path)
+      raise UsageError, "not a directory: #{path}" unless File.directory?(@dir)
+    end
+
+    def rev(ref)
+      git("rev-parse", "--verify", "--end-of-options", "#{ref}^{commit}").strip
+    end
+
+    # `ROOT^` names nothing in git. Reading it as the empty tree lets a
+    # review of the first commit use the same BASE HEAD form as any other.
+    def base_rev(ref)
+      rev(ref)
+    rescue GitError
+      child = ref.to_s[/\A(.+?)(?:\^1?|~1?)\z/, 1]
+      raise unless child && root_commit?(rev(child))
+
+      empty_tree
+    end
+
+    def empty_tree?(sha)
+      sha == empty_tree
+    end
+
+    def diff(base, head)
+      git(
+        "diff", "--unified=0", "--no-color", "--no-ext-diff", "--no-renames",
+        "--end-of-options", base, head
+      )
+    end
+
+    def name_status(base, head)
+      git("diff", "--name-status", "--no-renames", "--end-of-options", base, head)
+    end
+
+    # Oldest first. %(trailers) prints the block git itself parses as trailers,
+    # verbatim, so cutting it off the end of %B leaves the message without it.
+    def commit_messages(base, head)
+      range = empty_tree?(base) ? head : "#{base}..#{head}"
+      raw = git("log", "--reverse", "--format=%B%x1f%(trailers)%x1e", "--end-of-options", range)
+      raw.split("\x1e").filter_map do |record|
+        message, trailers = record.split("\x1f", 2)
+        next if trailers.nil?
+
+        message = message.rstrip
+        block = trailers.rstrip
+        block.empty? ? message : message.delete_suffix(block)
+      end
+    end
+
+    # The commits only base has, which `diff BASE HEAD` undoes, and the
+    # merge base `log BASE..HEAD` starts from. Nil when base is an ancestor.
+    def divergence(base, head)
+      return nil if empty_tree?(base)
+
+      _stdout, _stderr, status = capture("merge-base", "--is-ancestor", "--end-of-options", base, head)
+      return nil if status.success?
+
+      count = git("rev-list", "--count", "--end-of-options", "#{head}..#{base}").strip.to_i
+      fork = capture("merge-base", "--end-of-options", base, head).first.strip
+      { "base_only" => count, "merge_base" => fork.empty? ? nil : fork }
+    end
+
+    Blob = Data.define(:path, :oid, :size)
+
+    # A symlink is a blob that holds the path it points at, not Ruby. Its
+    # target is listed on its own when the repository holds it.
+    SYMLINK_MODE = "120000"
+
+    # The Ruby files and the ERB templates at ref.
+    # `-z` leaves a path with a tab, a newline, or a quote unquoted too.
+    def source_blobs(ref)
+      git("ls-tree", "-r", "-l", "-z", "--end-of-options", ref).split("\0").filter_map { |entry|
+        meta, path = entry.split("\t", 2)
+        mode, type, oid, size = meta.split
+        next unless type == "blob" && mode != SYMLINK_MODE && (path.end_with?(".rb") || Template.template?(path))
+
+        Blob.new(path: path, oid: oid, size: size.to_i)
+      }.sort_by(&:path)
+    end
+
+    # One `cat-file` reads every blob. A `git show` per file cost one process
+    # each, which was most of the time `context` took.
+    def read_blobs(oids)
+      return {} if oids.empty?
+
+      stdout, stderr, status = Open3.capture3(
+        "git", "--no-pager", "-C", @dir, "cat-file", "--batch",
+        stdin_data: "#{oids.join("\n")}\n", binmode: true
+      )
+      raise GitError, "git cat-file failed: #{stderr.strip}" unless status.success?
+
+      blobs = {}
+      offset = 0
+      while (newline = stdout.index("\n", offset))
+        oid, _type, size = stdout.byteslice(offset, newline - offset).split
+        blobs[oid] = as_utf8(stdout.byteslice(newline + 1, size.to_i))
+        offset = newline + size.to_i + 2
+      end
+      blobs
+    end
+
+    def show(ref, path)
+      stdout, _stderr, status = capture("show", "--end-of-options", "#{ref}:#{path}")
+      status.success? ? stdout : nil
+    end
+
+    # The parts of the Ruby files at ref that match pattern, an extended
+    # regexp, one per line. git grep exits 1 when nothing matches.
+    def ruby_matches(ref, pattern)
+      stdout, _stderr, status = capture("grep", "-h", "-o", "-I", "-E", "-e", pattern, ref, "--", "*.rb")
+      status.success? ? stdout : ""
+    end
+
+    def worktree_add(path, sha)
+      git("worktree", "add", "--detach", "--quiet", "--end-of-options", path, sha)
+    end
+
+    def worktree_remove(path)
+      return unless File.directory?(path)
+
+      _stdout, _stderr, status = capture("worktree", "remove", "--force", "--end-of-options", path)
+      FileUtils.remove_entry(path) if !status.success? && File.directory?(path)
+    end
+
+    def worktree_prune
+      capture("worktree", "prune")
+    end
+
+    def worktree_list
+      git("worktree", "list", "--porcelain")
+    end
+
+    def git(*args, env: nil)
+      stdout, stderr, status = capture(*args, env: env)
+      return stdout if status.success?
+
+      detail = stderr.strip
+      detail = stdout.strip if detail.empty?
+      raise GitError, "git #{args.first} failed: #{detail}"
+    end
+
+    private
+
+    def root_commit?(sha)
+      git("rev-list", "--parents", "-n", "1", "--end-of-options", sha).split.size == 1
+    end
+
+    def empty_tree
+      @empty_tree ||= git("hash-object", "-t", "tree", "--end-of-options", File::NULL).strip
+    end
+
+    # git quotes a path with non-ASCII bytes by default, and a quoted path
+    # names no file in `show` and matches no hunk path.
+    def capture(*args, env: nil)
+      command = ["git", "--no-pager", "-c", "core.quotePath=false", "-C", @dir, *args]
+      merged = ENV.to_h.merge(env || {})
+      stdout, stderr, status = Open3.capture3(merged, *command)
+      [as_utf8(stdout), as_utf8(stderr), status]
+    end
+
+    # Open3 tags output with the locale's encoding, which is US-ASCII under
+    # LANG=C. Paths, sources, and messages in a repository are UTF-8 bytes,
+    # and a stray invalid byte must not stop a regexp match.
+    def as_utf8(text)
+      text.force_encoding(Encoding::UTF_8)
+      text.valid_encoding? ? text : text.scrub("?")
+    end
+  end
+end

data/lib/jitcatch/inflections.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module JitCatch
+  # The English inflections Active Support starts from, and the literal
+  # `irregular`, `uncountable`, `singular`, `plural`, and `acronym` calls of
+  # an app's `config/initializers/inflections.rb`, read as source, so a
+  # route's helper and controller take the names Rails gives them
+  # (`resources :people` draws `person_path`, `inflect.acronym "API"` makes
+  # `APIKeysController`). A rule built at run time is not read.
+  class Inflections
+    def self.read(source)
+      inflections = rails
+      result = source ? Prism.parse(source) : nil
+      inflections.apply_calls(result.value) if result&.success?
+      inflections
+    end
+
+    # Active Support's own list, applied as an app's file would be, in the
+    # same order, so a later rule takes precedence as it does there.
+    def self.rails
+      inflections = new
+      [
+        [/$/, "s"], [/s$/i, "s"], [/^(ax|test)is$/i, '\1es'], [/(octop|vir)us$/i, '\1i'], [/(octop|vir)i$/i, '\1i'],
+        [/(alias|status)$/i, '\1es'], [/(bu)s$/i, '\1ses'], [/(buffal|tomat)o$/i, '\1oes'], [/([ti])um$/i, '\1a'],
+        [/([ti])a$/i, '\1a'], [/sis$/i, "ses"], [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'], [/(hive)$/i, '\1s'],
+        [/([^aeiouy]|qu)y$/i, '\1ies'], [/(x|ch|ss|sh)$/i, '\1es'], [/(matr|vert|ind)(?:ix|ex)$/i, '\1ices'],
+        [/^(m|l)ouse$/i, '\1ice'], [/^(m|l)ice$/i, '\1ice'], [/^(ox)$/i, '\1en'], [/^(oxen)$/i, '\1'], [/(quiz)$/i, '\1zes']
+      ].each { |rule, replacement| inflections.plural(rule, replacement) }
+      [
+        [/s$/i, ""], [/(ss)$/i, '\1'], [/(n)ews$/i, '\1ews'], [/([ti])a$/i, '\1um'],
+        [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis'], [/(^analy)(sis|ses)$/i, '\1sis'],
+        [/([^f])ves$/i, '\1fe'], [/(hive)s$/i, '\1'], [/(tive)s$/i, '\1'], [/([lr])ves$/i, '\1f'], [/([^aeiouy]|qu)ies$/i, '\1y'],
+        [/(s)eries$/i, '\1eries'], [/(m)ovies$/i, '\1ovie'], [/(x|ch|ss|sh)es$/i, '\1'], [/^(m|l)ice$/i, '\1ouse'],
+        [/(bus)(es)?$/i, '\1'], [/(o)es$/i, '\1'], [/(shoe)s$/i, '\1'], [/(cris|test)(is|es)$/i, '\1is'], [/^(a)x[ie]s$/i, '\1xis'],
+        [/(octop|vir)(us|i)$/i, '\1us'], [/(alias|status)(es)?$/i, '\1'], [/^(ox)en/i, '\1'], [/(vert|ind)ices$/i, '\1ex'],
+        [/(matr)ices$/i, '\1ix'], [/(quiz)zes$/i, '\1'], [/(database)s$/i, '\1']
+      ].each { |rule, replacement| inflections.singular(rule, replacement) }
+      %w[person people man men child children sex sexes move moves zombie zombies].each_slice(2) { |one, many| inflections.irregular(one, many) }
+      inflections.uncountable(*%w[equipment information rice money species series fish sheep jeans police])
+      inflections
+    end
+
+    def initialize
+      @plurals = []
+      @singulars = []
+      @uncountables = []
+      @acronyms = {}
+    end
+
+    def pluralize(word) = apply(word, @plurals)
+
+    def singularize(word) = apply(word, @singulars)
+
+    # `api_keys` is `APIKeys` once `API` is an acronym.
+    def camelize(word)
+      word.split("_").map { |part| @acronyms[part] || part.capitalize }.join
+    end
+
+    # The other way: `APIKeysController` is `api_keys_controller`, as Active
+    # Support's `underscore` splits a run of capitals before its last one.
+    def underscore(camel)
+      camel.gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+    end
+
+    def plural(rule, replacement)
+      @uncountables.delete(rule) if rule.is_a?(String)
+      @uncountables.delete(replacement)
+      @plurals.unshift([rule, replacement])
+    end
+
+    def singular(rule, replacement)
+      @uncountables.delete(rule) if rule.is_a?(String)
+      @uncountables.delete(replacement)
+      @singulars.unshift([rule, replacement])
+    end
+
+    def irregular(one, many)
+      @uncountables.delete(one)
+      @uncountables.delete(many)
+      first, rest = one[0], one[1..]
+      many_first, many_rest = many[0], many[1..]
+      if first.upcase == many_first.upcase
+        plural(/(#{first})#{rest}$/i, "\\1#{many_rest}")
+        plural(/(#{many_first})#{many_rest}$/i, "\\1#{many_rest}")
+        singular(/(#{first})#{rest}$/i, "\\1#{rest}")
+        singular(/(#{many_first})#{many_rest}$/i, "\\1#{rest}")
+      else
+        plural(/#{first.upcase}(?i)#{rest}$/, many_first.upcase + many_rest)
+        plural(/#{first.downcase}(?i)#{rest}$/, many_first.downcase + many_rest)
+        plural(/#{many_first.upcase}(?i)#{many_rest}$/, many_first.upcase + many_rest)
+        plural(/#{many_first.downcase}(?i)#{many_rest}$/, many_first.downcase + many_rest)
+        singular(/#{first.upcase}(?i)#{rest}$/, first.upcase + rest)
+        singular(/#{first.downcase}(?i)#{rest}$/, first.downcase + rest)
+        singular(/#{many_first.upcase}(?i)#{many_rest}$/, first.upcase + rest)
+        singular(/#{many_first.downcase}(?i)#{many_rest}$/, first.downcase + rest)
+      end
+    end
+
+    def uncountable(*words)
+      @uncountables.concat(words.flatten)
+    end
+
+    def acronym(word)
+      @acronyms[word.downcase] = word
+    end
+
+    # Each call in the file whose arguments are all literals, in order.
+    def apply_calls(node)
+      node.compact_child_nodes.each { |child| apply_calls(child) }
+      return unless node.is_a?(Prism::CallNode) && READ.include?(node.name) && node.receiver
+
+      args = Array(node.arguments&.arguments).map { |arg| literal(arg) }
+      public_send(node.name, *args) unless args.empty? || args.include?(UNREAD)
+    end
+
+    READ = %i[plural singular irregular uncountable acronym].freeze
+    UNREAD = Object.new.freeze
+
+    private
+
+    def apply(word, rules)
+      return word if word.empty? || @uncountables.any? { |uncountable| word.match?(/\b#{Regexp.escape(uncountable)}\Z/i) }
+
+      result = word.dup
+      rules.each { |rule, replacement| break if result.sub!(rule, replacement) }
+      result
+    end
+
+    def literal(node)
+      case node
+      when Prism::StringNode, Prism::SymbolNode then node.unescaped
+      when Prism::RegularExpressionNode then Regexp.new(node.unescaped, node.options)
+      when Prism::ArrayNode
+        items = node.elements.map { |element| literal(element) }
+        items.include?(UNREAD) ? UNREAD : items
+      else UNREAD
+      end
+    end
+  end
+end

data/lib/jitcatch/minitest_parser.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module JitCatch
+  # Reads the report minitest_report.rb writes in a Minitest candidate's
+  # process, and Minitest's output for an error that stopped the file.
+  class MinitestParser
+    HEADER = /^(\S.*?)(?:\s+\[(.+):(\d+)\])?:\s*$/.freeze
+    STATUSES = { "F" => "fail", "E" => "error" }.freeze
+    # minitest_report.rb prints the error an error was raised from under
+    # this line, between the message and the frames.
+    CAUSED_BY = "--- Caused by: ---"
+    FINISHED = "finished"
+
+    def self.parse(report, stdout, stderr, normalizer: ->(text) { text })
+      new(report.to_s, normalizer.call(stdout.to_s), normalizer.call(stderr.to_s), normalizer).parse
+    end
+
+    def initialize(report, stdout, stderr, normalizer)
+      @report = report
+      @stdout = stdout.gsub("\r\n", "\n")
+      @stderr = stderr.gsub("\r\n", "\n")
+      @normalizer = normalizer
+    end
+
+    def parse
+      tests = {}
+      summary = false
+      @report.each_line do |raw|
+        # A process killed while it wrote leaves its last line cut.
+        next unless raw.end_with?("\n")
+
+        line = raw.chomp
+        next summary = true if line == FINISHED
+
+        name, code, text = line.split("\t", 3).map { |field| readable(field.undump) }
+        tests[name] = result(code, @normalizer.call(text.to_s))
+      end
+
+      file_error = summary ? nil : Failure.from_streams(@stdout, @stderr)
+      if !summary && tests.empty? && file_error.nil?
+        file_error = Failure.result("error", "RuntimeError", "minitest summary not found", [])
+      end
+      { "tests" => tests, "lines" => {}, "summary" => summary, "file_error" => file_error }
+    end
+
+    private
+
+    # A message can hold bytes that are not UTF-8; they read as "?", as in the
+    # streams the runner reads.
+    def readable(text)
+      text = text.dup.force_encoding(Encoding::UTF_8)
+      text.valid_encoding? ? text : text.scrub("?")
+    end
+
+    # The text is what Minitest prints for a result in its summary: the
+    # failure's label line, the test's location, then the message.
+    def result(code, text)
+      status = STATUSES[code]
+      return Failure.passed(code == "S" ? "skip" : "pass") unless status
+
+      parse_issue(status, text.gsub("\r\n", "\n").lines(chomp: true).drop(1))
+    end
+
+    def parse_issue(status, block)
+      match = block.shift.to_s.match(HEADER)
+      frames = []
+      frames << Failure.frame(match[2], match[3]) if match&.[](2)
+      body, backtrace = status == "error" ? split_backtrace(block) : [block, []]
+      message_lines = []
+      quoting = false
+      body.each do |line|
+        # assert_raises prints the frames of the error it got between these
+        # two lines. The frames move to the backtrace, so the lines go too.
+        if line == "---Backtrace---" || (quoting && line.match?(/\A-+\z/))
+          quoting = !quoting
+          next
+        end
+        if quoting && (frame = line.match(Failure::FRAME))
+          frames << Failure.frame(frame[1], frame[2])
+          next
+        end
+        message_lines << line
+      end
+      error_class = "Minitest::Assertion" if status == "fail"
+      if status == "error" && (err = message_lines.first.to_s.match(/\A([A-Za-z0-9_:]+): ?(.*)\z/))
+        error_class = err[1]
+        message_lines[0] = err[2]
+      end
+      cause = nil
+      if status == "error" && (at = message_lines.index(CAUSED_BY))
+        cause_lines = message_lines.drop(at + 1)
+        message_lines = message_lines.take(at)
+        named = cause_lines.first.to_s.match(/\A([A-Za-z0-9_:]+): ?(.*)\z/)
+        cause = { "error_class" => named ? named[1] : "", "message" => [named ? named[2] : cause_lines.first.to_s, *cause_lines.drop(1)].join("\n") }
+      end
+      Failure.result(status, error_class, message_lines.join("\n"), frames + Failure.frames_in(backtrace), cause: cause)
+    end
+
+    # An error prints "Class: message", then each frame on a line of its own
+    # indented four spaces. A message line can look like a frame, so only the
+    # indented frames at the end of the block are the backtrace.
+    def split_backtrace(block)
+      lines = block.dup
+      lines.pop while lines.last&.strip&.empty?
+      at = lines.size
+      at -= 1 while at.positive? && lines[at - 1].start_with?("    ") && lines[at - 1].match?(Failure::FRAME)
+      [lines.take(at), lines.drop(at)]
+    end
+  end
+end

data/lib/jitcatch/minitest_report.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Loaded into a Minitest candidate's process with `ruby -r`, never into
+# jitcatch itself. It writes each result to a report file for
+# MinitestParser, since the lines Minitest prints for a test can be split or
+# joined by what the test prints and by tests that run at once. It loads no
+# library beyond minitest, so the candidate's process sees no other change.
+begin
+  require "minitest"
+rescue LoadError
+  # A bundle without minitest is named by the bundle check, not here.
+else
+  # Minitest prints an error's class, message, and frames, but not the
+  # error it was raised from, so this puts that error's class and message
+  # between the message and the frames, under the line RSpec prints for
+  # the same thing.
+  Minitest::UnexpectedError.prepend(Module.new do
+    def message
+      text = super
+      cause = error.cause
+      head = "#{error.class}: #{error.message}"
+      return text unless cause && text.start_with?(head)
+
+      "#{head}\n--- Caused by: ---\n#{cause.class}: #{cause.message}#{text[head.length..]}"
+    end
+  end)
+
+  # One line per result: the test's name, its result code, and the text
+  # Minitest prints for it (a passing test's location), each as a
+  # String#dump literal and joined by tabs, then a last line once the run
+  # finished. Each line is written as it comes, so a run that is killed
+  # keeps the results it reported.
+  jitcatch_report = Class.new(Minitest::AbstractReporter) do
+    # Framework::REPORT, resolved before a test can change the directory.
+    define_method(:initialize) { @io = File.open(File.expand_path(".jitcatch-report.json"), "wb").tap { |io| io.sync = true } }
+
+    def record(result)
+      @io.write("#{[[result.class_name, result.name].join("#"), result.result_code, result.to_s].map(&:dump).join("\t")}\n")
+    end
+
+    def report
+      @io.write("finished\n")
+    end
+  end
+
+  Minitest.singleton_class.prepend(Module.new do
+    # Plugins add their reporters here. Registering an extension instead
+    # would stop Minitest 5 from loading the plugins of installed gems.
+    define_method(:init_plugins) do |options|
+      super(options)
+      reporter << jitcatch_report.new
+    end
+  end)
+end