duel 0.1.0

data/lib/duel/process_sample.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "native"
+
+module Duel
+  # The runs of a process benchmark (see DSL#duel_process) for one worker:
+  # each a fresh process, started and waited for by a Ruby process of its
+  # own (the runner's Ruby, out of any bundle) that has nothing else to
+  # wait for, so what its child took is the process's alone, even while
+  # the runner waits for others. That Ruby process starts with the first
+  # run and is kept for the worker's life, so that its start is paid once,
+  # not for every run. For each run, it reports a line of JSON: the CPU
+  # time the process took (user and system, its children's too), its peak
+  # memory where it can tell, and how it ended.
+  # @api private
+  class ProcessSample
+    # The lines of its output a failure shows.
+    LOG_LINES = 10
+
+    # Runs for the worker +label+, in +chdir+ with +env+ (over the
+    # runner's own), each process's output to +log+. A run that takes
+    # more than +timeout+ seconds fails.
+    def initialize(label, env:, chdir:, log:, timeout:)
+      @label = label
+      @env = env
+      @chdir = chdir
+      @log = log
+      @timeout = timeout
+    end
+
+    # The fastest of +samples+ (one version's runs, as #run returns them):
+    # the least CPU time, and the least peak memory where every one has
+    # it.
+    def self.fastest(samples)
+      peaks = samples.map { |sample| sample.fetch("peak") }
+      cpu = samples.map { |sample| sample.fetch("timed").fetch("cpu") }.min #: Integer
+      {"timed" => {"cpu" => cpu}, "counted" => {}, "heap" => 0, "peak" => (peaks.min unless peaks.include?(nil))}
+    end
+
+    # Runs +command+ (as Process.spawn takes it) once, and returns its
+    # sample ({"timed" => {"cpu" => nanoseconds}, "peak" => bytes or nil},
+    # as a worker's has it). One that fails, or takes more than the
+    # timeout (it's killed, with what it started, and the Ruby process
+    # that ran it), fails.
+    def run(command)
+      start unless @pid
+      @requests.puts JSON.generate(command)
+      unless @replies.wait_readable(@timeout)
+        kill
+        raise Failed, "#{@label}: #{command.join(" ")} didn't end within #{@timeout}s (killed)"
+      end
+      reply = @replies.gets
+      unless reply
+        stop
+        raise Failed, "#{@label}: the process running #{command.join(" ")} exited"
+      end
+
+      ended = JSON.parse(reply)
+      failed = ended.fetch("failed")
+      if failed
+        tail = File.readlines(@log).last(LOG_LINES).join
+        raise Failed, "#{@label}: #{command.join(" ")} #{failed}#{"\n#{tail}" unless tail.empty?}"
+      end
+      {"timed" => {"cpu" => ended.fetch("cpu")}, "counted" => {}, "heap" => 0, "peak" => ended.fetch("peak")}
+    end
+
+    # Ends the Ruby process of its own, if it started: closing its input
+    # does.
+    def stop
+      pid = @pid
+      return unless pid
+
+      @requests.close
+      Process.wait(pid)
+      @replies.close
+      @pid = nil
+    end
+
+    # Runs a process for each line of +input+ (a command, in JSON), with
+    # what +spec+ says ({"env", "chdir", "log"}), and reports each (see
+    # .once) as a line of +output+, at once, until the input ends: run in
+    # the Ruby process of its own.
+    def self.main(spec, input: $stdin, output: $stdout)
+      spec = JSON.parse(spec)
+      output.sync = true
+      while (line = input.gets)
+        output.puts JSON.generate(once(JSON.parse(line), spec.fetch("env"), spec.fetch("chdir"), spec.fetch("log")))
+      end
+    end
+
+    # Runs +command+ once, in +chdir+ with +env+ alone, its output to
+    # +log+, and returns what it took: its CPU time, its peak memory (or
+    # nil), and how it failed (or nil).
+    def self.once(command, env, chdir, log)
+      before = cpu
+      code, signal, peak = Native::Child.wait(Process.spawn(env, *command, chdir: chdir, in: File::NULL, out: [log, "w"],
+        err: [:child, :out], unsetenv_others: true, close_others: true))
+      {"cpu" => cpu - before, "peak" => peak, "failed" => (why(code, signal) unless code == 0)}
+    end
+
+    # The CPU time of the children waited for so far, in nanoseconds.
+    def self.cpu
+      times = Process.times
+      ((times.cutime + times.cstime) * 1_000_000_000).round
+    end
+
+    # How a process that failed ended: its exit status +code+, or the
+    # +signal+ that killed it.
+    def self.why(code, signal)
+      return "exited with #{code}" if code
+
+      killed = signal #: Integer
+      "was killed by SIG#{Signal.signame(killed)}"
+    end
+
+    private
+
+    # Starts the Ruby process of its own, given the environment, the
+    # directory and the log, and connected by a pipe each way (not a
+    # socket: JRuby's spawn can't give one).
+    def start
+      spec = JSON.generate({"env" => {**ENV, **@env}, "chdir" => @chdir, "log" => @log})
+      requests, @requests = IO.pipe
+      @replies, replies = IO.pipe
+      # (Out of the runner's bundle: it needs nothing of it.)
+      @pid = Process.spawn({"RUBYOPT" => nil, "RUBYLIB" => nil}, RbConfig.ruby,
+        *WorkerProcess.load_path(RbConfig.ruby).flat_map { |lib| ["-I", lib] }, "-r", "duel/process_sample", "-e",
+        "Duel::ProcessSample.main(*ARGV)", spec, in: requests, out: replies, pgroup: true, close_others: true)
+      requests.close
+      replies.close
+    end
+
+    # Kills the Ruby process of its own, and what it started.
+    def kill
+      pid = @pid #: Integer
+      Process.kill("KILL", -pid)
+      Process.wait(pid)
+      @requests.close
+      @replies.close
+      @pid = nil
+    end
+  end
+end

data/lib/duel/profile.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Duel
+  # Where a regression's time went: StackProf profiles of each version,
+  # over the same iterations (Lane#profile), so a frame's samples compare
+  # directly: the frames that gained the most CPU, in themselves, are the
+  # place to start looking.
+  # @api private
+  class Profile
+    # Why there's no profile: StackProf runs on CRuby only, so the hint
+    # reads right on JRuby and TruffleRuby too.
+    UNAVAILABLE = "a profile of each version needs CRuby, with the stackprof gem in the bundle"
+    TOP = 8
+    # Frames kept in the report, per version.
+    KEPT = 200
+
+    # StackProf's frames for garbage collection, which isn't the
+    # benchmark's code: what it gained is reported apart (see #gc).
+    GC = "(garbage collection)"
+    GC_FRAMES = [GC, "(marking)", "(sweeping)"].freeze
+
+    # The frames that mark a benchmark's measured work (see Harness and
+    # ProfileSample): its iterations, and what they left to do, are inside
+    # Harness#iterate, an untimed block and around_iteration hooks' own
+    # work are inside ProfileSample#pause, and an iteration inside its
+    # hooks is inside Harness#iteration, inside that pause.
+    ITERATE = "Duel::Harness#iterate"
+    PAUSE = "Duel::ProfileSample#pause"
+    ITERATION = "Duel::Harness#iteration"
+
+    # A version's profile, from StackProf's +results+ (raw, so with each
+    # sample's stack): every frame's samples [name, own, total], most total
+    # first, and how many samples there were. Only the benchmark's work is
+    # kept, and garbage collection (reported apart: see #gc). Frames of
+    # one name, from different places, are one.
+    def self.of(results)
+      names = results.fetch(:frames).transform_values { |frame| frame.fetch(:name) }
+      # @type var frames: Hash[String, [Integer, Integer]]
+      frames = Hash.new do |h, k|
+        h[k] = [0, 0] #: [Integer, Integer]
+      end
+      samples = 0
+      # (Each stack: its depth, its frames, outermost first, and how many
+      # samples in a row had it. None at all without samples.)
+      raw = results.fetch(:raw, []) #: Array[Integer]
+      i = 0
+      while i < raw.size
+        depth = raw.fetch(i)
+        stack = Array.new(depth) { |j| names.fetch(raw.fetch(i + 1 + j)) }
+        count = raw.fetch(i + 1 + depth)
+        i += depth + 2
+        next unless kept?(stack)
+
+        samples += count
+        frames[stack.last][0] += count
+        stack.uniq.each { |name| frames[name][1] += count }
+      end
+      {"samples" => samples, "frames" => frames.sort_by { |_, (_, total)| -total }.map { |frame, (own, total)| [frame, own, total] }}
+    end
+
+    # Whether a sample, by its stack's frames' names (outermost first), is
+    # of garbage collection or the benchmark's measured work: inside its
+    # iterations and not paused, or, if paused, in an iteration inside the
+    # innermost pause. So the work of pausing and resuming around each
+    # iteration, which a Sample takes away (see Harness#leak), is left
+    # out too.
+    def self.kept?(stack)
+      return true if GC_FRAMES.include?(stack.first)
+
+      paused = stack.rindex(PAUSE)
+      return stack.include?(ITERATE) unless paused
+
+      iteration = stack.rindex(ITERATION)
+      !iteration.nil? && iteration > paused
+    end
+
+    def initialize(profiles)
+      @baseline = profiles.fetch("baseline")
+      @candidate = profiles.fetch("candidate")
+    end
+
+    # [frame, own, total] for the TOP frames that gained the most samples
+    # of their own: what each gained, in itself and with what it called,
+    # as a share of all the baseline's samples (+0.05: 5% more CPU there).
+    def grew
+      base = counts(@baseline)
+      whole = samples
+      # (Only frames the candidate has can have gained.)
+      @candidate.fetch("frames").filter_map do |frame, own_now, total_now|
+        # (Steep takes the default for an Array of any length.)
+        own_was, total_was = base.fetch(frame, [0, 0]) #: [Integer, Integer]
+        next if own_now <= own_was || GC_FRAMES.include?(frame)
+
+        [frame, (own_now - own_was) / whole, (total_now - total_was) / whole] #: growth
+      end.sort_by { |_, own, _| -own }.first(TOP)
+    end
+
+    # What garbage collection gained, as a share of all the baseline's
+    # samples: collecting the garbage of each sample before the next (a
+    # profile's samples hold the collector off, as measured ones do).
+    def gc = (collecting(@candidate) - collecting(@baseline)) / samples
+
+    def to_h = {"grew" => grew, "gc" => gc, "baseline" => trimmed(@baseline), "candidate" => trimmed(@candidate)}
+
+    private
+
+    def samples = [@baseline.fetch("samples"), 1].max.to_f
+
+    def counts(profile) = profile.fetch("frames").to_h { |frame, own, total| [frame, [own, total]] }
+
+    # A profile's samples in garbage collection.
+    def collecting(profile) = profile.fetch("frames").find { |frame, _, _| frame == GC }&.last || 0
+
+    def trimmed(profile) = {"samples" => profile.fetch("samples"), "frames" => profile.fetch("frames").first(KEPT)}
+  end
+end

data/lib/duel/rake_task.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "rake"
+require_relative "cli"
+
+module Duel
+  # A rake task running `duel` with +args+:
+  #
+  #   require "duel/rake_task"
+  #   Duel::RakeTask.new(:perf)
+  #   Duel::RakeTask.new(:perf_since_release, "--base", "last-release")
+  class RakeTask
+    include Rake::DSL
+
+    def initialize(name = :duel, *args)
+      desc "Fail if this tree is slower than its baseline at any benchmark (duel)"
+      task(name) do
+        case CLI.new(args).run
+        when 1 then abort "duel: slower than the baseline"
+        when 2 then abort "duel: couldn't compare"
+        end
+      end
+    end
+  end
+end

data/lib/duel/resource.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+
+module Duel
+  # What a prepare block (see Config#prepare) gets: a worker's, or a
+  # version's, own directory, and help running commands and starting a
+  # server there, and stopping it.
+  #
+  #   c.prepare(:worker) do |w|
+  #     socket = w.path("redis.sock")
+  #     w.spawn("redis-server", "--port", "0", "--unixsocket", socket, "--save", "")
+  #     w.wait_until { File.socket?(socket) }
+  #     {"REDIS_URL" => "unix://#{socket}"}
+  #   end
+  #
+  # The block returns the environment the worker (or the version's
+  # workers) gets. When the worker is done (or the run, for a version),
+  # Duel runs the #at_stop blocks (last first), then stops what was
+  # spawned.
+  class Resource
+    # Seconds between looks while waiting (#wait_until).
+    # @api private
+    POLL = 0.01
+
+    # Seconds a process gets to end after its stop signal before it's
+    # killed.
+    # @api private
+    STOP_WAIT = 5
+
+    # The lines of its log a failure shows.
+    # @api private
+    LOG_LINES = 10
+
+    # What a cache key may be.
+    # @api private
+    KEY = /\A[\w.-]+\z/
+
+    # The lock on building a cache (each worker is prepared on a thread
+    # of its own).
+    # @api private
+    CACHE = Mutex.new
+
+    # The worker it's for ("baseline-1", say), or the version ("baseline",
+    # for Config#prepare(:version)), the directory it has of its own, the
+    # tree of the version that worker runs, and the Ruby it runs on (see
+    # Config#ruby).
+    attr_reader :name, :dir, :root, :ruby
+
+    # What its commands (#spawn, #run) get in their environment, under
+    # their own: its version's (what Config#prepare(:version) returned, and
+    # its Ruby's: see Rubies.environment).
+    attr_reader :env
+
+    # +env+ with +vars+ (a prepare block's, for +name+) too: two that set
+    # a variable differently fail.
+    # @api private
+    def self.environment(name, env, vars)
+      env.merge(vars) do |var, mine, theirs|
+        raise Failed, "#{name}: two prepare blocks set #{var} (#{mine}, #{theirs})" unless mine == theirs
+
+        mine
+      end
+    end
+
+    # @api private
+    def initialize(dir, name, root, timeout:, cache:, ruby: RbConfig.ruby, env: {})
+      @name = name
+      @dir = dir
+      @root = root
+      @ruby = ruby
+      @env = env
+      @timeout = timeout
+      @cache = cache
+      @processes = {}
+      @stops = []
+      FileUtils.mkdir_p(dir)
+    end
+
+    # A path in its directory. (Unix socket paths are short: up to 104
+    # bytes on macOS. Duel's directories leave room.)
+    def path(file) = File.join(@dir, file)
+
+    # A directory built once, by the block, for every worker of this run
+    # and later ones (a database's initial files, say, for each worker to
+    # copy): the first that asks for +key+ builds it, in a directory the
+    # block is given, and the rest get it built. A key names what's built
+    # (put a version in it), as a file name: tmp/duel/cache/+key+, which
+    # `duel --clean` removes. A build that fails leaves nothing behind.
+    def cached(key)
+      raise ArgumentError, "a cache key is a file name (letters, digits, - _ .), not #{key.inspect}" unless key.match?(KEY)
+
+      dir = File.join(@cache, key)
+      CACHE.synchronize { build(dir) { |building| yield building } unless File.directory?(dir) }
+      dir
+    end
+
+    # Starts a process (as Process.spawn takes it), its output added to a
+    # log in the directory (+log+.log: by default, its program's name),
+    # and stopped with the resource, by +stop_signal+ (then KILL, five
+    # seconds later). Returns its pid. Its input is
+    # nothing, and it gets no other file descriptors, unless +options+
+    # say otherwise (in:, close_others:). It runs in its version's
+    # environment (on its Ruby: see Config#ruby), under any it's given.
+    def spawn(*command, log: nil, stop_signal: "TERM", **options)
+      log = log_path(command, log)
+      pid = start(command, log, options)
+      @processes[pid] = [File.basename(log, ".log"), log, stop_signal]
+      pid
+    end
+
+    # Runs a command (setting something up, say) to its end, its output
+    # added to a log as #spawn's is. It fails, showing it, unless it
+    # succeeds.
+    def run(*command, log: nil, **options)
+      log = log_path(command, log)
+      _, status = Process.wait2(start(command, log, options))
+      return if status.success?
+
+      code = status.exitstatus
+      signal = status.termsig #: Integer
+      failed("#{File.basename(log, ".log")} #{code ? "exited with #{code}" : "was killed by SIG#{Signal.signame(signal)}"}", log: log)
+    end
+
+    # Waits until the block is true: fails if a process spawned dies
+    # first, or the run's timeout (--timeout) passes.
+    def wait_until
+      deadline = monotonic + @timeout
+      until yield
+        ended = @processes.find { |pid, _| Process.wait(pid, Process::WNOHANG) }
+        if ended
+          # (It may have got ready, and ended, since the last look.)
+          break if yield
+
+          program, log = ended.last
+          failed("#{program} exited before it was ready", log: log)
+        end
+        failed("not ready within #{@timeout}s", log: @processes.values.last&.fetch(1)) if monotonic > deadline
+        sleep POLL
+      end
+    end
+
+    # Runs the block when the resource stops, before its processes do.
+    def at_stop(&block) = @stops << block
+
+    # Fails, saying it's this resource that did, with the end of +log+ (a
+    # path) to say why.
+    def failed(message, log: nil)
+      tail = log ? File.readlines(log).last(LOG_LINES).join : ""
+      raise Failed, "#{@name}'s resource: #{message}#{"\n#{tail}" unless tail.empty?}"
+    end
+
+    # Stops it: the at_stop blocks, last first, then each process.
+    # @api private
+    def stop
+      @stops.reverse_each(&:call)
+      @processes.each { |pid, (_, _, signal)| end_process(pid, signal) }
+    end
+
+    private
+
+    # Builds +dir+ in a directory of its own, then renames it into place:
+    # if another run got there first, its build stands.
+    def build(dir)
+      building = "#{dir}.#{Process.pid}.building"
+      begin
+        FileUtils.rm_rf(building)
+        FileUtils.mkdir_p(building)
+        yield building
+        File.rename(building, dir)
+      rescue SystemCallError, IOError # (JRuby's, renaming onto a directory)
+        raise unless File.directory?(dir)
+      ensure
+        FileUtils.rm_rf(building)
+      end
+    end
+
+    # The log a command's output goes to: +name+.log, or its program's.
+    def log_path(command, name) = path("#{name || File.basename(command.grep(String).fetch(0).split.fetch(0))}.log")
+
+    def start(command, log, options)
+      # (Its own environment, if it's given one, over its version's.)
+      none = {} #: Hash[String, String?]
+      env, *program = command.first.is_a?(Hash) ? command : [none, *command]
+      out = File.new(log, "a") # (here, so it's there for a failure to show)
+      begin
+        Process.spawn(@env.merge(env), *program, in: File::NULL, out: out, err: out, close_others: true, **options)
+      ensure
+        out.close
+      end
+    end
+
+    # (Waited for on a thread of its own: a Timeout can't interrupt a wait
+    # on JRuby.)
+    def end_process(pid, signal)
+      Process.kill(signal, pid)
+      waiter = Process.detach(pid)
+      return if waiter.join(STOP_WAIT)
+
+      Process.kill("KILL", pid)
+      waiter.join
+    rescue Errno::ESRCH # gone already
+      nil
+    end
+
+    def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/duel/rubies.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rbconfig"
+require_relative "../duel"
+
+module Duel
+  # The Ruby each version runs on (Config#ruby): by default the runner's.
+  # With :version_file, it's the one the version's own version file names
+  # (.ruby-version, .tool-versions or mise.toml, in its tree or above it):
+  # the runner's own, if it's that one, or else the one installed with
+  # whichever of rbenv, chruby, mise and asdf has it. Or it's a path, or
+  # what a block makes of the version's tree.
+  # @api private
+  module Rubies
+    # The files that name a Ruby, in the order they're looked at in each
+    # directory.
+    VERSION_FILES = %w[.ruby-version .tool-versions mise.toml .mise.toml].freeze
+
+    # Where chruby finds Rubies.
+    CHRUBY = ["/opt/rubies", File.join(Dir.home, ".rubies")].freeze
+
+    # Where each manager has a version of Ruby installed (its prefix), or
+    # nil: rbenv's and asdf's by exact name (without "ruby-"), chruby's as
+    # chruby matches it, and mise's as mise does (3.4: the newest 3.4).
+    MANAGERS = {
+      "rbenv" => ->(version) { Rubies.command("rbenv", "prefix", version.delete_prefix("ruby-")) },
+      "chruby" => ->(version) { Rubies.chruby(version) },
+      "mise" => ->(version) { Rubies.command("mise", "where", "ruby@#{version.delete_prefix("ruby-")}") },
+      "asdf" => ->(version) { Rubies.command("asdf", "where", "ruby", version.delete_prefix("ruby-")) }
+    }.freeze
+
+    # A Ruby's own variables, set by a manager (chruby's gems, say) for the
+    # Ruby it chose: wrong for any other.
+    VARIABLES = %w[GEM_HOME GEM_PATH GEM_ROOT RUBY_ROOT RUBY_ENGINE RUBY_VERSION RUBY_PATCHLEVEL RBENV_VERSION
+      MISE_RUBY_VERSION ASDF_RUBY_VERSION].freeze
+
+    class << self
+      # The Ruby (its executable) that +choice+ gives the version +name+d
+      # ("baseline") at +root+: one that isn't there fails.
+      def find(choice, root, name)
+        ruby = case choice
+        when nil then RbConfig.ruby
+        when :version_file then from_version_file(root, name)
+        when String then choice
+        else choice.call(root)
+        end
+        raise Error, "the #{name}'s Ruby (#{ruby}) isn't there" unless File.file?(ruby) && File.executable?(ruby)
+
+        ruby
+      end
+
+      # Whether +ruby+ is the runner's own.
+      def runner?(ruby) = File.realpath(ruby) == File.realpath(RbConfig.ruby)
+
+      # What a version's processes on +ruby+ get in their environment:
+      # nothing on the runner's Ruby. On another, its directory first on
+      # +path+ (for what they start by name, `bundle` say), and none of the
+      # runner's Ruby's VARIABLES.
+      def environment(ruby, path: ENV["PATH"])
+        return {} if runner?(ruby)
+
+        VARIABLES.to_h { |variable| [variable, nil] }.merge("PATH" => [File.dirname(ruby), path].compact.join(File::PATH_SEPARATOR))
+      end
+
+      # The nearest version file, from +root+ up, that names a Ruby, and the
+      # version it names: [file, version], or nil.
+      def requested(root)
+        dir = File.expand_path(root)
+        loop do
+          VERSION_FILES.each do |name|
+            file = File.join(dir, name)
+            version = (read(file) if File.file?(file))
+            return [file, version] if version
+          end
+          return if dir == (dir = File.dirname(dir))
+        end
+      end
+
+      # The version of Ruby a version file names, or nil (a .tool-versions
+      # of other tools, say).
+      def read(file)
+        text = File.read(file)
+        case File.basename(file)
+        when ".ruby-version" then text.split.first
+        when ".tool-versions" then text[/^ruby[ \t]+(\S+)/, 1]
+        else
+          # (mise.toml's [tools], up to the next table: ruby = "3.4",
+          # ruby = ["3.4"], or ruby = { version = "3.4" }.)
+          tools = text.partition(/^\[tools\]/).last.split(/^\[/).first
+          tools&.[](/^[ \t]*"?ruby"?[ \t]*=[ \t]*[\[{]?[ \t]*(?:version[ \t]*=[ \t]*)?"([^"]+)"/, 1)
+        end
+      end
+
+      # Where chruby has +version+: the Ruby of that name, or else the last
+      # (by name) whose name has it in it.
+      def chruby(version)
+        dirs = CHRUBY.flat_map { |rubies| Dir.glob(File.join(rubies, "*")) }
+        dirs.find { |dir| File.basename(dir) == version } || dirs.reverse.find { |dir| File.basename(dir).include?(version) }
+      end
+
+      # Whether +version+, as a version file names it, is the runner's own
+      # Ruby (by its +engine+ and its +engine_version+), as the managers
+      # match one: with or without "ruby-" for CRuby (a bare version is
+      # CRuby's), with its engine's name for another ("jruby-10.1.2.0",
+      # "truffleruby+graalvm-24.1.0"), and exactly or by its first parts
+      # ("3.4" for 3.4.11, as mise and chruby take it).
+      def runner_asked?(version, engine: RUBY_ENGINE, engine_version: RUBY_ENGINE_VERSION)
+        match = /\A(?:([a-z]+)(?:\+[^-]+)?-)?(\d[\w.]*)\z/.match(version)
+        return false unless match
+
+        name, number = match.captures
+        (name || "ruby") == engine && (engine_version == number || engine_version.start_with?("#{number}."))
+      end
+
+      # What a command prints, or nil if it fails (or isn't there).
+      def command(*command)
+        out, _, status = Open3.capture3(*command)
+        out.strip if status.success?
+      rescue SystemCallError
+        nil
+      end
+
+      private
+
+      # The Ruby the nearest version file names (see #requested): the
+      # runner's, if it's that one (see #runner_asked?) or there's no
+      # version file, or else the first manager's that has it.
+      def from_version_file(root, name)
+        requested = requested(root)
+        return RbConfig.ruby unless requested
+
+        file, version = requested
+        # (The runner's own, if it's the one asked for: installed where no
+        # manager looks, by CI's setup step, say.)
+        return RbConfig.ruby if runner_asked?(version)
+
+        MANAGERS.each_value do |manager|
+          prefix = manager.call(version)
+          # (JRuby's may have no bin/ruby.)
+          ruby = prefix && %w[ruby jruby].map { |program| File.join(prefix, "bin", program) }.find { |path| File.executable?(path) }
+          return ruby if ruby
+        end
+        raise Error, "the #{name}'s #{file} asks for Ruby #{version}, which isn't installed with rbenv, chruby, mise or " \
+          "asdf: install it, or set c.ruby in .duel.rb"
+      end
+    end
+  end
+end