duel 0.1.1 → 0.1.2

data/docs/configuration.md

@@ -17,6 +17,9 @@ Duel.configure do |c|
   c.release_tags = "release-*"           # default: v*
   c.ruby = :version_file                 # each version's own Ruby (default: the runner's)
   c.comment = :results                   # when CI comments on a pull request (default: :failures)
+  c.fail_on = :pull_requests             # which runs a regression fails (default: :every_run)
+  c.push_base = :last_passed             # what CI compares a push with (default: :before)
+  c.accept_label = "duel: accept"        # a pull request label that accepts a regression
   c.use :redis                           # a plugin (see Use plugins)
 
   # How a worker loads one version of your code, instead of the library.
@@ -90,6 +93,83 @@ with a nonzero status, and the job's summary still has the report.
 `c.comment` takes only these four values: any other fails the run, and
 says which values it takes.
 
+## Fail only a pull request
+
+By default, a regression fails every run: a pull request's, a push's,
+and the schedule's. In a project where people push to `main` directly,
+a failed push only gets GitHub's email that the run failed. To report a
+regression in a push without failing it, set `c.fail_on`, and
+`duel --fail-on` overrides it:
+
+| Value | Which runs a regression fails |
+|---|---|
+| `:every_run` | Every run. This is the default. |
+| `:pull_requests` | A pull request's (or a merge queue's), and a run outside GitHub Actions. |
+
+```ruby
+Duel.configure do |c|
+  c.fail_on = :pull_requests
+end
+```
+
+With `:pull_requests`, a regression on GitHub Actions outside a pull
+request (a push, the schedule, or a run by hand) passes, with a warning
+in the run's summary, and the job's summary still has the report. On
+GitLab CI, a regression outside a merge request exits with status 3,
+which the [job](ci.md#run-duel-on-gitlab-ci) that `duel init --gitlab`
+writes shows as a warning. The
+[GitHub Actions workflow](ci.md#comment-on-a-pushed-commit) that
+`duel init` writes then comments on a pushed commit with the report,
+as `c.comment` says, which notifies the commit's author. A run that
+couldn't compare fails either way, and on your machine, a regression
+always fails.
+
+## Accept a regression with a label
+
+Sometimes a change is slower on purpose: it's correct where the old
+code wasn't, say. To let a pull request through anyway, name a label
+that accepts its regression:
+
+```ruby
+Duel.configure do |c|
+  c.accept_label = "duel: accept"
+end
+```
+
+On GitHub Actions, the [workflow](ci.md#accept-a-regression-with-a-label)
+that `duel init` writes passes Duel the pull request's labels. With
+that label, a regression passes, with a warning, and the report says
+that the label accepted it. The labels are read when the workflow runs,
+so after you add the label, run the workflow again (Re-run jobs, on the
+pull request's Checks tab). For a push, Duel reads the labels of the
+pull request that merged it, so with
+[`c.push_base = :last_passed`](#compare-a-push-with-the-last-commit-that-passed),
+the merged regression becomes the commit that later pushes are compared
+with. By default, there's no such label.
+
+## Compare a push with the last commit that passed
+
+The [GitHub Actions workflow](ci.md#compare-a-push-with-the-last-commit-that-passed)
+that `duel init` writes compares a push to `main` with the commit
+before it. A series of pushes that are each a little slower then each
+pass. `c.push_base` chooses what a push is compared with:
+
+| Value | What the workflow compares a push with |
+|---|---|
+| `:before` | The commit before the push. This is the default. |
+| `:last_passed` | The last commit that Duel passed, which a branch marks: `duel/passed/main` for `main`. |
+
+```ruby
+Duel.configure do |c|
+  c.push_base = :last_passed
+end
+```
+
+With `:last_passed`, the slowdowns add up until they fail a push. After
+a regression, every push fails until one is no slower, or until you
+move the branch to accept the regression:
+`git push origin main:duel/passed/main`.
+
 ## Prepare each worker
 
 Each worker can get things of its own, such as a server, so that the

data/docs/how-it-works.md

@@ -140,7 +140,10 @@ iteration, as they are in the explanation of a regression.
 The main branch is the one that `origin/HEAD` names. Without
 `origin/HEAD`, Duel uses `origin/main`, and then `origin/master`. In a
 repository without a remote, it uses `main`, and then `master`. To name
-another branch, set `c.main_branch`.
+another branch, set `c.main_branch`. On GitHub Actions, for a pull
+request, the main branch is the one that the pull request targets
+(`GITHUB_BASE_REF`), such as a stable branch, or another pull request's
+branch in a stack of them.
 
 Duel checks out a git baseline as a git worktree next to your project,
 under a hidden name that's as long as your project's directory name, for

data/lib/duel/baseline.rb

@@ -11,12 +11,15 @@ module Duel
   # git commit checked out (and built, see Config#build) where #checkout
   # says. Settings#base names the commit:
   #
-  # - nil: where HEAD left the main branch (their merge base):
+  # - nil: where HEAD left the main branch (their merge base): for a
+  #   pull request, the branch it targets (Settings#target), or else
   #   Config#main_branch, or the one origin/HEAD names, or origin/main, or
   #   origin/master, or (a repository without a remote) main, or master
   # - "last-release": the newest release tag (Config#release_tags) before
   #   HEAD, to catch slowdowns too small for any one change to fail but
   #   that add up between releases
+  # - a push's (Settings#pushed, the branch pushed): the commit before it, or where
+  #   Config#push_base says, the last commit Duel passed (#passed)
   # - anything else: a git ref
   # @api private
   class Baseline
@@ -29,17 +32,29 @@ module Duel
       @settings = settings
     end
 
-    # The commit, or nil for "last-release" with no release yet.
+    # The commit, or nil for "last-release" with no release yet, and for
+    # a push with no commit before it here (see #pushed).
     def ref
       return @ref if instance_variable_defined?(:@ref)
 
       @ref = case @settings.base
       when nil then merge_base
       when LAST_RELEASE then git("describe", "--tags", "--abbrev=0", "--match", @config.release_tags, "HEAD^", allow_failure: true)
-      else @settings.base
+      else @settings.pushed ? pushed : @settings.base
       end
     end
 
+    # The branch that marks the last commit Duel passed in a push to the
+    # branch pushed (Settings#pushed), for Config#push_base:
+    # duel/passed/main, or for a project in a subdirectory of its
+    # repository, with its path (duel/passed-gems-parser/main), so each
+    # branch, and each of a monorepo's projects, has its own.
+    def passed_branch = "#{prefix.empty? ? "duel/passed" : "duel/passed-#{prefix.tr("/", "-")}"}/#{@settings.pushed}"
+
+    # The last commit Duel passed in a push, as checked out from GitHub
+    # (#passed_branch, on origin).
+    def passed = "origin/#{passed_branch}"
+
     # Whether nothing #watched changed since the baseline (only for a git
     # baseline compared with the working tree).
     def unchanged?
@@ -122,7 +137,7 @@ module Duel
 
     # The main branch (see #ref).
     def main_branch
-      @config.main_branch ||
+      @settings.target || @config.main_branch ||
         git("symbolic-ref", "--short", "refs/remotes/origin/HEAD", allow_failure: true) ||
         BRANCHES.find { |branch| git("rev-parse", branch, allow_failure: true) } ||
         raise(Error, "no main branch to compare with (set c.main_branch in .duel.rb, or --base)")
@@ -178,6 +193,17 @@ module Duel
       raise Error, "HEAD and #{branch} have no commit in common: #{why}, or compare with --base REF"
     end
 
+    # A push's baseline: the last commit Duel passed (#passed), where
+    # Config#push_base says and HEAD has it, or else the commit before the
+    # push, or nil where that isn't here (a branch's first push, or one
+    # that rewrote history).
+    def pushed
+      return passed if @config.push_base == :last_passed && git("merge-base", "--is-ancestor", passed, "HEAD", allow_failure: true)
+
+      before = @settings.base #: String
+      before if git("cat-file", "-e", "#{before}^{commit}", allow_failure: true)
+    end
+
     # Whether +dir+ is a checkout of this repository (a worktree of it).
     def ours?(dir) = common_dir(dir) == common_dir(@config.root)
 

data/lib/duel/cli.rb

@@ -18,7 +18,8 @@ module Duel
   # On GitHub Actions (GITHUB_STEP_SUMMARY), it adds its report to the
   # job's summary, in Markdown (see Summary), and tells the step's
   # outputs (GITHUB_OUTPUT) what to do about the comment on a pull
-  # request (see .comment). --markdown writes the Markdown to a file, and
+  # request (see .comment), and for a push, whether to mark it passed
+  # (see Config#push_base). --markdown writes the Markdown to a file, and
   # --json the report as JSON (see JSONReport), whatever the run's
   # outcome, but not for a command line that isn't valid.
   # @api private
@@ -32,6 +33,10 @@ module Duel
     # Where GitHub Actions has a step set its outputs.
     STEP_OUTPUT = "GITHUB_OUTPUT"
 
+    # Where else to write them, as variables (DUEL_COMMENT, DUEL_STATUS,
+    # DUEL_PASSED): on GitLab CI, a dotenv report, for the jobs after.
+    OUTPUT = "DUEL_OUTPUT"
+
     # The statuses (as the JSON report has them) that the workflow
     # comments on, by when it does (Config#comment, but :never, which
     # comments on none).
@@ -41,6 +46,16 @@ module Duel
     # has it: passed, failed (or couldn't compare), or neutral.
     MARKED = {"passed" => "passed", "failed" => "failed", "error" => "failed", "nothing_to_compare" => "neutral"}.freeze
 
+    # The GitHub Actions events of a pull request, as GITHUB_EVENT_NAME
+    # has them: a merge queue's too (see Config#fail_on). (A GitLab merge
+    # request's is pull_request: see #event.)
+    PULL_REQUESTS = %w[pull_request pull_request_target merge_group].freeze
+
+    # The exit status of a run that was slower outside a merge request on
+    # GitLab CI, where only a merge request fails (Config#fail_on): the
+    # job that `duel init --gitlab` writes lets it fail, as a warning.
+    WARNED = 3
+
     # The variables that set options, to their values, and the one that
     # sets a flag by being set at all.
     ENV_OPTIONS = {"DUEL_BASE" => "--base", "DUEL_FILTER" => "--filter"}.freeze
@@ -54,7 +69,8 @@ module Duel
     end
 
     # Runs, and returns the exit status: 0 not slower (or nothing to compare),
-    # 1 slower (or a benchmark failed), 2 couldn't compare.
+    # 1 slower (or a benchmark failed), 2 couldn't compare, 3 slower but
+    # warned (see WARNED).
     def run
       return Init.new(@argv.drop(1), out: @out, err: @err).run if @argv.first == "init"
 
@@ -91,9 +107,17 @@ module Duel
 
     # The mode --comment names (see Config#comment), or an invalid
     # argument.
-    def self.comment_mode(name)
-      Config::COMMENTS.find { |mode| mode.to_s == name } or
-        raise OptionParser::InvalidArgument, "#{name} (give #{Config::COMMENTS.join(", ")})"
+    def self.comment_mode(name) = named(name, Config::COMMENTS)
+
+    # The runs --fail-on names (see Config#fail_on), or an invalid
+    # argument.
+    def self.fail_on(name) = named(name, Config::FAIL_ON)
+
+    # Which of +values+ (symbols) an option's argument names, or an
+    # invalid argument.
+    def self.named(name, values)
+      values.find { |value| value.to_s == name } or
+        raise OptionParser::InvalidArgument, "#{name} (give #{values.join(", ")})"
     end
 
     # The settings, from the environment and then the options.
@@ -101,6 +125,11 @@ module Duel
       settings = Settings.defaults
       settings.jobs = [Etc.nprocessors / 2, 1].max
       parser(settings).parse!(env_options + @argv)
+      branch = variable("GITHUB_REF_NAME", "CI_COMMIT_BRANCH")
+      base = variable("DUEL_BASE")
+      settings.pushed = branch if pushed? && !base.nil? && settings.base == base
+      target = variable("GITHUB_BASE_REF", "CI_MERGE_REQUEST_TARGET_BRANCH_NAME")
+      settings.target = "origin/#{target}" if target && pull_request?
       settings.config_path ||= (".duel.rb" if File.exist?(".duel.rb"))
       settings.config_path &&= File.expand_path(settings.config_path)
       settings
@@ -117,9 +146,12 @@ module Duel
         return 0
       end
       if settings.base_dir.nil? && baseline.ref.nil?
+        return nothing("no commit to compare against", "no commit before this push to compare against") if settings.pushed
+
         return nothing("no release to compare against", "no release tag (#{config.release_tags}) before HEAD to compare against")
       end
       if !settings.force && baseline.unchanged?
+        @passed = marks_passed?(config, settings)
         return nothing("nothing to compare",
           "#{baseline.watched.join(", ")} unchanged since the baseline, so there's nothing to compare (--force to anyway)")
       end
@@ -130,12 +162,14 @@ module Duel
       uneven(base_root, candidate)
       runner = Runner.new(config, settings, base_root, out: @out)
       results = runner.run
-      status = runner.passed?(results) ? 0 : 1
+      passed = runner.passed?(results)
+      status = passed ? 0 : slower(config, settings)
+      @passed = (passed || accepted?(config)) && marks_passed?(config, settings)
       publish(
-        status.zero? ? "passed" : "failed",
+        passed ? "passed" : "failed",
         -> {
           Summary.new(runner, results, settings: settings, baseline: described_baseline(config, settings, baseline),
-            candidate: described_candidate(config, settings)).markdown
+            candidate: described_candidate(config, settings), note: @note).markdown
         },
         ->(comment) {
           JSONReport.new(runner, results, settings: settings, exit: status, comment: comment,
@@ -145,6 +179,107 @@ module Duel
       status
     end
 
+    # The exit status of a run that was slower (or whose benchmark
+    # failed): 1, or 0 where the pull request's label accepts it
+    # (Config#accept_label), or on GitHub Actions outside a pull request,
+    # where c.fail_on (or --fail-on) says only a pull request fails, with
+    # a warning that says so, and a note in the report.
+    def slower(config, settings)
+      if accepted?(config)
+        # (Set: see #accepted?.)
+        label = config.accept_label #: String
+        return passing("accepted with the #{label} label", "Accepted with the #{Summary.code(label)} label.")
+      end
+      return 1 unless pull_requests_only?(config, settings)
+      return 1 unless outside_pull_request?
+
+      # (Outside a pull request on CI, so there's one: see #event.)
+      run = event #: String
+      passing("only a pull request fails (c.fail_on), so this #{run} passes",
+        "Only a pull request fails (#{Summary.code("c.fail_on")}), so this #{run} passes.", gitlab? ? WARNED : 0)
+    end
+
+    # Passes a run that was slower (or on GitLab CI, warns: +exit+), as
+    # +why+ says, in a warning (on GitHub Actions, an annotation), and as
+    # +note+ says in the report.
+    def passing(why, note, exit = 0)
+      @out.puts "#{gitlab? ? "duel: " : "::warning::Duel: "}slower, but #{why}"
+      @note = note
+      exit
+    end
+
+    # Whether the pull request's labels have the one that accepts a
+    # regression (Config#accept_label).
+    def accepted?(config)
+      label = config.accept_label
+      !label.nil? && labels.include?(label)
+    end
+
+    # The pull request's labels: DUEL_LABELS (a JSON array of their names)
+    # on GitHub Actions, or a GitLab merge request's
+    # (CI_MERGE_REQUEST_LABELS, by commas), or none, where neither is
+    # set, or DUEL_LABELS isn't a JSON array.
+    def labels
+      set = variables
+      return set.fetch("CI_MERGE_REQUEST_LABELS").split(",") if !set.key?("DUEL_LABELS") && set.key?("CI_MERGE_REQUEST_LABELS")
+      return [] unless set.key?("DUEL_LABELS")
+
+      names = JSON.parse(set.fetch("DUEL_LABELS"))
+      names.instance_of?(Array) ? names : []
+    rescue JSON::ParserError
+      []
+    end
+
+    # Whether the workflow marks a push that passed (or had nothing to
+    # compare) as the last commit Duel passed: where Config#push_base
+    # says to compare a push with that commit.
+    def marks_passed?(config, settings) = !settings.pushed.nil? && config.push_base == :last_passed
+
+    # Whether a regression fails only a pull request (--fail-on, or else
+    # Config#fail_on).
+    def pull_requests_only?(config, settings) = (settings.fail_on || config.fail_on) == :pull_requests
+
+    # What a run on CI is for, as GitHub Actions names it
+    # (GITHUB_EVENT_NAME): push, pull_request, schedule, say. On GitLab
+    # CI, its pipeline's source (CI_PIPELINE_SOURCE), as GitHub would
+    # name it: a merge request's is pull_request. Outside CI, nil.
+    def event
+      github = variable("GITHUB_EVENT_NAME")
+      return github if github
+      return unless gitlab?
+
+      source = variable("CI_PIPELINE_SOURCE")
+      (source == "merge_request_event") ? "pull_request" : source
+    end
+
+    # Whether this is a run on GitLab CI.
+    def gitlab? = variables.key?("GITLAB_CI")
+
+    # Whether this is a run on CI for something other than a pull request
+    # (PULL_REQUESTS): a push, say.
+    def outside_pull_request?
+      run = event
+      !run.nil? && !PULL_REQUESTS.include?(run)
+    end
+
+    # Whether this is a run on CI for a pull request (or a merge queue:
+    # see PULL_REQUESTS).
+    def pull_request? = PULL_REQUESTS.include?(event)
+
+    # Whether the baseline is a merge queue's base: on GitHub Actions for
+    # a merge queue, as DUEL_BASE gives it.
+    def queued?(settings) = event == "merge_group" && settings.base == variable("DUEL_BASE")
+
+    # Whether this is a run on CI for a push.
+    def pushed? = event == "push"
+
+    # The first of the variables +names+ that's set, or nil.
+    def variable(*names)
+      set = variables
+      name = names.find { |n| set.key?(n) }
+      set.fetch(name) if name
+    end
+
     # Says there's nothing to compare (+title+, in Markdown), and +why+,
     # and passes.
     def nothing(title, why)
@@ -161,14 +296,19 @@ module Duel
       exit
     end
 
-    # What the workflow does about its comment on a pull request (see
-    # .comment), for a run whose +status+ is the JSON report's: as
-    # --comment says, or else the configuration, or the default where the
-    # configuration didn't load.
+    # What the workflow does about its comment on a pull request, or on
+    # a pushed commit (see .comment), for a run whose +status+ is the
+    # JSON report's: as --comment says, or else the configuration, or the
+    # default where the configuration didn't load. It comments on a push
+    # only where a regression in one passes (Config#fail_on), so the
+    # comment says what the check doesn't.
     def commenting(status)
       # (Parsed, so set: see #run.)
       settings = @settings #: Settings
-      CLI.comment(settings.comment || (@config || Config.new).comment, status)
+      config = @config || Config.new
+      return "none" if pushed? && !pull_requests_only?(config, settings)
+
+      CLI.comment(settings.comment || config.comment, status)
     end
 
     # Writes the reports of a run whose +status+ is the JSON report's
@@ -177,13 +317,17 @@ module Duel
     # --json names, and the Markdown +markdown+ makes to the file
     # --markdown names, and added to the job's summary on GitHub Actions
     # (STEP_SUMMARY). Each is only made if it's written. On GitHub
-    # Actions, it also sets the step's outputs (STEP_OUTPUT) for the job
-    # that comments on a pull request: +comment+, and +status+ as the
-    # comment's marker has it (MARKED).
+    # Actions, it also sets the step's outputs (STEP_OUTPUT) for the jobs
+    # that comment: +comment+, and +status+ as the comment's marker has
+    # it (MARKED), and for the job that marks a push passed, "passed"
+    # (see #marks_passed?). Where DUEL_OUTPUT names a file (OUTPUT), it
+    # writes them there too, as variables.
     def publish(status, markdown, json)
       comment = commenting(status)
       set = variables
-      File.write(set.fetch(STEP_OUTPUT), "comment=#{comment}\nstatus=#{MARKED.fetch(status)}\n", mode: "a") if set.key?(STEP_OUTPUT)
+      outputs = "comment=#{comment}\nstatus=#{MARKED.fetch(status)}\n#{"passed=true\n" if @passed}"
+      File.write(set.fetch(STEP_OUTPUT), outputs, mode: "a") if set.key?(STEP_OUTPUT)
+      File.write(set.fetch(OUTPUT), outputs.gsub(/^\w+=/) { |name| "DUEL_#{name.upcase}" }, mode: "a") if set.key?(OUTPUT)
       path = @json
       write(path, "#{JSON.pretty_generate(json.call(comment))}\n") if path
       path = @markdown
@@ -204,7 +348,9 @@ module Duel
     # The baseline, in Markdown: its directory, or its commit, bare (so
     # GitHub links it) and followed by a space, never punctuation, and
     # what chose it: the main branch, the push (on GitHub Actions, the
-    # commit before it, from DUEL_BASE), the last release, or --base.
+    # commit before it, from DUEL_BASE, or the last commit Duel passed),
+    # the merge queue (its base, from DUEL_BASE), the last release, or
+    # --base.
     def described_baseline(config, settings, baseline)
       dir = settings.base_dir
       return Summary.code(dir) if dir
@@ -212,15 +358,13 @@ module Duel
       # (There's one: #compare checked.)
       ref = baseline.ref #: String
       commit = git(config.root, "rev-parse", "--short", "#{ref}^{commit}").first.chomp
-      set = variables
       chosen = case settings.base
       when nil then "where HEAD left #{Summary.code(baseline.main_branch)}"
       when Baseline::LAST_RELEASE then "the last release, #{Summary.code(ref)}"
       else
-        pushed = set.key?("GITHUB_EVENT_NAME") && set.fetch("GITHUB_EVENT_NAME") == "push" && set.key?("DUEL_BASE") &&
-          set.fetch("DUEL_BASE") == ref
-        if !ref.match?(/\A\h+\z/) then Summary.code(ref)
-        elsif pushed then "the commit before the push"
+        if settings.pushed then (ref == baseline.passed) ? "the last commit Duel passed" : "the commit before the push"
+        elsif queued?(settings) then "the merge queue's base"
+        elsif !ref.match?(/\A\h+\z/) then Summary.code(ref)
         else "from --base"
         end
       end
@@ -248,11 +392,7 @@ module Duel
 
       # (There's one: #compare checked.)
       ref = baseline.ref #: String
-      named = case settings.base
-      when nil then baseline.main_branch
-      when Baseline::LAST_RELEASE then ref
-      else settings.base
-      end
+      named = settings.base ? ref : baseline.main_branch
       described.merge("ref" => named, "commit" => git(config.root, "rev-parse", "#{ref}^{commit}").first.chomp)
     end
 
@@ -322,6 +462,8 @@ module Duel
         o.on("--json PATH", "Also write the report to PATH as JSON, for a program to read") { |v| @json = v }
         o.on("--comment MODE", "When the workflow comments on a pull request: always, results (passed or failed),",
           "failures, or never (default: c.comment, or failures)") { |v| settings.comment = CLI.comment_mode(v) }
+        o.on("--fail-on RUNS", "Which runs a regression fails: every_run, or pull_requests (on GitHub Actions, another",
+          "warns and passes) (default: c.fail_on, or every_run)") { |v| settings.fail_on = CLI.fail_on(v) }
         o.on("--clean", "Remove tmp/duel, and the baseline's git worktree, and stop") { @clean = true }
         o.on("-v", "--version", "Print the version") do
           @out.puts "duel #{VERSION}"

data/lib/duel/config.rb

@@ -95,6 +95,75 @@ module Duel
       @comment = mode
     end
 
+    # Which runs a regression fails (`duel --fail-on` overrides it):
+    #
+    # - :every_run (the default)
+    # - :pull_requests, only a pull request's (or a merge queue's), and a
+    #   run outside GitHub Actions. On GitHub Actions, a regression in
+    #   any other run (a push, the schedule, run by hand) passes, with a
+    #   warning, and the workflow that `duel init` writes comments on a
+    #   pushed commit with the report, as #comment says, which notifies
+    #   its author.
+    #
+    # A run that couldn't compare fails either way.
+    #
+    #   c.fail_on = :pull_requests
+    attr_reader :fail_on
+
+    # The values #fail_on takes.
+    FAIL_ON = %i[every_run pull_requests].freeze #: Array[fail_on]
+
+    def fail_on=(runs)
+      raise Error, "c.fail_on = #{runs.inspect}: give #{FAIL_ON.map(&:inspect).join(", ")}" unless FAIL_ON.include?(runs)
+
+      @fail_on = runs
+    end
+
+    # The name of a label that accepts a regression in a pull request
+    # (or nil, the default, for none): on GitHub Actions, the workflow
+    # that `duel init` writes passes Duel the pull request's labels
+    # (DUEL_LABELS), and with this one, a regression passes, with a
+    # warning, and the report says it was accepted. For a push, it's the
+    # labels of the pull request that merged it, so where #push_base is
+    # :last_passed, the push is marked passed too. The labels are read
+    # when the workflow runs, so after adding the label, run it again.
+    #
+    #   c.accept_label = "duel: accept"
+    attr_reader :accept_label
+
+    def accept_label=(label)
+      raise Error, "c.accept_label = #{label.inspect}: give a label's name, or nil" unless label.nil? || label.instance_of?(String)
+
+      @accept_label = label
+    end
+
+    # What the workflow that `duel init` writes compares a push with:
+    #
+    # - :before (the default), the commit before the push
+    # - :last_passed, the last commit Duel passed, which the workflow
+    #   marks with a branch, duel/passed/main for main (see
+    #   Baseline#passed_branch),
+    #   when a push passes, or has nothing to compare. Slowdowns too
+    #   small for any one push to fail then add up until they fail one,
+    #   and a push the workflow didn't compare (its run cancelled, say)
+    #   is compared with the next. After a regression, every push is
+    #   compared with the commit before it, until one is no slower, or
+    #   the branch is moved to accept the regression. Without the branch,
+    #   or where HEAD doesn't have its commit (after a force push, say),
+    #   a push is compared with the commit before it.
+    #
+    #   c.push_base = :last_passed
+    attr_reader :push_base
+
+    # The values #push_base takes.
+    PUSH_BASES = %i[before last_passed].freeze #: Array[push_base]
+
+    def push_base=(base)
+      raise Error, "c.push_base = #{base.inspect}: give #{PUSH_BASES.map(&:inspect).join(", ")}" unless PUSH_BASES.include?(base)
+
+      @push_base = base
+    end
+
     # The metrics #metric added, in order (classes: a Duel::Metric
     # subclass, or running totals' Snapshot), for a plugin's tests to
     # look at (their .measures and .settings).
@@ -115,6 +184,8 @@ module Duel
       @build = :conventional
       @release_tags = "v*"
       @comment = :failures
+      @fail_on = :every_run
+      @push_base = :before
       @prepares = SCOPES.to_h { |scope| [scope, []] }
       @metrics = []
       @in_workers = []

data/lib/duel/init.rb

@@ -10,15 +10,17 @@ require_relative "../duel"
 module Duel
   # `duel init`: sets Duel up in a gem or an app that isn't a Rails app
   # (duel-rails's generator sets a Rails app up). It writes .duel.rb, a
-  # benchmark to start from, and a GitHub Actions workflow, adds a Rake
+  # benchmark to start from, and GitHub Actions workflows (Duel's, and
+  # one that comments on a pull request with its report), or with
+  # --gitlab, GitLab CI jobs to include, adds a Rake
   # task to the Rakefile, and adds StackProf to the Gemfile (for profiles
   # of regressions, on CRuby). It overwrites nothing without --force, and
   # writes nothing with --dry-run.
   # @api private
   class Init
     USAGE = "Usage: duel init [options]\n\n" \
-      "Sets Duel up in this project: .duel.rb, a benchmark to start from in duel/, a GitHub Actions workflow,\n" \
-      "a Rake task, and StackProf in the Gemfile.\n\n"
+      "Sets Duel up in this project: .duel.rb, a benchmark to start from in duel/, GitHub Actions workflows\n" \
+      "(or GitLab CI jobs), a Rake task, and StackProf in the Gemfile.\n\n"
 
     TEMPLATES = File.join(__dir__, "templates")
 
@@ -61,8 +63,13 @@ module Duel
 
     # The files it writes, from the project's root, to what's in them.
     def files
-      workflow = Pathname(File.realpath(repository)).relative_path_from(File.realpath(@root)).join(".github", "workflows", workflow_name)
-      {".duel.rb" => render("duel.rb"), benchmark_file => render("benchmark_duel.rb"), workflow.to_s => render("perf.yml")}
+      top = Pathname(File.realpath(repository)).relative_path_from(File.realpath(@root))
+      written = {".duel.rb" => render("duel.rb"), benchmark_file => render("benchmark_duel.rb")}
+      return written.merge(top.join(gitlab_file).to_s => render("duel.gitlab-ci.yml")) if @gitlab
+
+      workflows = top.join(".github", "workflows")
+      written.merge(workflows.join(workflow_name).to_s => render("perf.yml"),
+        workflows.join(workflow_name.sub(/\.yml\z/, "-comment.yml")).to_s => render("perf-comment.yml"))
     end
 
     private
@@ -72,6 +79,7 @@ module Duel
         o.banner = USAGE
         o.on("--force", "Overwrite files that exist") { @force = true }
         o.on("--dry-run", "Say what it would do, and write nothing") { @dry_run = true }
+        o.on("--gitlab", "Write GitLab CI jobs (to include from .gitlab-ci.yml), not GitHub Actions workflows") { @gitlab = true }
         o.on("-h", "--help", "Print this help") do
           @out.puts o
           throw :help
@@ -156,8 +164,13 @@ module Duel
       steps << "Set c.library in .duel.rb to what each version's workers require." unless required
       steps << "Replace the example in #{benchmark_file} with benchmarks of your own code."
       steps << "Run `bundle exec duel --force`. It compares the code with itself, and passes when the benchmarks are sound."
-      steps << "Commit and push. On a pull request, the workflow compares the code with the main branch, and comments with the " \
-        "report when a benchmark fails (c.comment in .duel.rb says when)."
+      steps << if @gitlab
+        "Include #{gitlab_file} from .gitlab-ci.yml, and add the tokens it says to, for comments. On a merge request, the job " \
+          "compares the code with the branch it targets."
+      else
+        "Commit and push. On a pull request, the workflow compares the code with the branch it targets, and comments with the " \
+          "report when a benchmark fails (c.comment in .duel.rb says when)."
+      end
       "\nNext:\n#{steps.each_with_index.map { |step, i| "  #{i + 1}. #{step}\n" }.join}"
     end
 
@@ -215,5 +228,26 @@ module Duel
 
     # What marks the workflow's comment on a pull request.
     def marker = ["duel", working_directory].compact.join(" ")
+
+    # Where the GitLab CI jobs are, from the repository's root:
+    # .gitlab/duel.gitlab-ci.yml, or for a project in a subdirectory,
+    # .gitlab/duel-<its path>.gitlab-ci.yml.
+    def gitlab_file = File.join(".gitlab", "#{["duel", working_directory&.tr("/", "-")].compact.join("-")}.gitlab-ci.yml")
+
+    # The GitLab CI job's name: duel, or for a project in a subdirectory,
+    # duel:<its path>, so each of a monorepo's projects has its own.
+    def gitlab_job = ["duel", working_directory].compact.join(":")
+
+    # The Ruby image's tag for GitLab CI: the version .ruby-version names,
+    # exactly (so it's the Ruby that c.ruby = :version_file asks for), or
+    # this one's minor version.
+    def gitlab_ruby
+      named = File.read(File.join(@root, ".ruby-version")).split.first if version_file
+      named&.delete_prefix("ruby-") || RUBY_VERSION.rpartition(".").first
+    end
+
+    # What names the branches that mark the last commit Duel passed in a
+    # push, before the branch pushed's name (see Baseline#passed_branch).
+    def passed_branch = ["duel/passed", working_directory&.tr("/", "-")].compact.join("-")
   end
 end