duel 0.1.1 → 0.1.2

data/lib/duel/runner.rb

@@ -30,7 +30,7 @@ module Duel
   # How a run is set up (see Duel::CLI for where each comes from).
   # @api private
   Settings = Struct.new(:base, :base_dir, :candidate_dir, :filter, :jobs, :processes, :limit, :confidence, :warm, :force,
-    :config_path, :timeout, :ruby, :comment) do
+    :config_path, :timeout, :ruby, :comment, :fail_on, :pushed, :target) do
     # @type self: singleton(Settings)
     def self.defaults = new(filter: //, jobs: 1, processes: 3, limit: 1.02, confidence: 0.99, warm: nil, force: false,
       timeout: 60.0)

data/lib/duel/summary.rb

@@ -90,8 +90,10 @@ module Duel
 
     # +runner+ ran, and made +results+, comparing +baseline+ with
     # +candidate+ (each a description, in Markdown, whose commit stands
-    # bare, so GitHub links it) as +settings+ say.
-    def initialize(runner, results, settings:, baseline:, candidate:)
+    # bare, so GitHub links it) as +settings+ say, with a +note+ (in
+    # Markdown) under the heading, if there's one.
+    def initialize(runner, results, settings:, baseline:, candidate:, note: nil)
+      @note = note
       @runner = runner
       @results = results
       @settings = settings
@@ -114,7 +116,7 @@ module Duel
 
     # The Markdown, with the first +explained+ regressions explained.
     def render(explained)
-      [heading, compared, failures, across(confirmed: true), details(explained)].compact.join("\n\n") + "\n"
+      [heading, @note, compared, failures, across(confirmed: true), details(explained)].compact.join("\n\n") + "\n"
     end
 
     # The verdict: what failed (benchmarks, or a metric across the board),

data/lib/duel/templates/duel.gitlab-ci.yml.erb

@@ -0,0 +1,148 @@
+# Duel on GitLab CI: https://github.com/sferik/duel-ruby/blob/main/docs/ci.md#run-duel-on-gitlab-ci
+#
+# Include it from .gitlab-ci.yml:
+#
+#   include:
+#     - local: <%= gitlab_file %>
+#
+# It compares a merge request with the branch it targets, a push to the
+# default branch with the commit before it (or as c.push_base in .duel.rb
+# says, the last commit Duel passed), and on a schedule, the last release.
+# The Duel job's log, and its duel.md artifact, have the report. Comments
+# need project access tokens, in masked CI/CD variables:
+#
+# - DUEL_COMMENT_TOKEN (the Reporter role, with the api scope, and not
+#   protected), to comment on a merge request. Every job of a merge
+#   request's pipeline has it, the Duel job too, which runs the merge
+#   request's code, so the token can do no more than comment.
+# - DUEL_TOKEN (the Developer role, with the api scope, and protected, so
+#   only the default branch's pipelines have it), to comment on a pushed
+#   commit (see c.fail_on), and to mark a push passed (see c.push_base).
+
+<%= gitlab_job %>:
+  image: ruby:<%= gitlab_ruby %>
+  stage: test
+  variables:
+    GIT_DEPTH: 0 # the baseline comes from history, tags included
+    DUEL_OUTPUT: duel.env # whether to comment, and mark a push passed
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+      variables:
+        DUEL_BASE: $CI_COMMIT_BEFORE_SHA
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      variables:
+        DUEL_BASE: last-release
+    # (Run by hand, it compares anyway: with nothing changed, the code
+    # with itself, which checks the setup.)
+    - if: $CI_PIPELINE_SOURCE == "web"
+      variables:
+        DUEL_FORCE: "1"
+  # A regression outside a merge request, where only a merge request
+  # fails (c.fail_on in .duel.rb), exits 3: a warning.
+  allow_failure:
+    exit_codes: [3]
+  before_script:
+<% if working_directory -%>
+    - cd <%= working_directory %>
+<% end -%>
+    # The branch a merge request targets, the last commits Duel passed,
+    # and the releases.
+    - git fetch --quiet --tags origin "+refs/heads/duel/*:refs/remotes/origin/duel/*"
+    - if [ -n "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME" ]; then git fetch --quiet origin "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME"; fi
+    - bundle install
+  script:
+    - bundle exec duel --markdown duel.md
+  artifacts:
+    when: always
+    paths:
+      - <%= working_directory ? "#{working_directory}/" : "" %>duel.md
+    reports:
+      dotenv: <%= working_directory ? "#{working_directory}/" : "" %>duel.env
+    expire_in: 1 day
+
+# The report, as a new comment on the merge request, when Duel says to:
+# always (post), or only when its last comment's status differs from this
+# run's (change), so the latest comment is never stale. It never edits or
+# deletes a comment.
+<%= gitlab_job %>:comment:
+  image: alpine:3
+  stage: .post
+  needs: [<%= gitlab_job %>]
+  rules:
+    - if: $DUEL_COMMENT_TOKEN && $CI_PIPELINE_SOURCE == "merge_request_event"
+      when: always
+  variables:
+    GIT_STRATEGY: none # it runs none of the code
+  script:
+    - apk add --no-cache --quiet curl jq
+    - |
+      case "$DUEL_COMMENT" in post|change) ;; *) exit 0 ;; esac
+      report=<%= working_directory ? "#{working_directory}/" : "" %>duel.md
+      [ -f "$report" ] || exit 0
+      api="$CI_API_V4_URL/projects/$CI_PROJECT_ID"
+      token="PRIVATE-TOKEN: $DUEL_COMMENT_TOKEN"
+      marker="<!-- <%= marker %>"
+      me=$(curl -sf -H "$token" "$CI_API_V4_URL/user" | jq .id)
+      # The first line of the last comment Duel posted here: its marker,
+      # with its status.
+      last=$(curl -sf -H "$token" "$api/merge_requests/$CI_MERGE_REQUEST_IID/notes?sort=desc&order_by=created_at&per_page=100" |
+        jq -r --argjson me "$me" --arg marker "$marker status=" '.[] | select(.author.id == $me) | .body | split("\n")[0] | rtrimstr("\r") | select(startswith($marker))' | head -n 1)
+      if [ "$DUEL_COMMENT" = post ] || { [ -n "$last" ] && [ "$last" != "$marker status=$DUEL_STATUS -->" ]; }; then
+        { echo "$marker status=$DUEL_STATUS -->"; cat "$report"; } | jq -Rs '{body: .}' |
+          curl -sf -H "$token" -H "Content-Type: application/json" --data @- "$api/merge_requests/$CI_MERGE_REQUEST_IID/notes" > /dev/null
+      fi
+
+# The report, as a new comment on a pushed commit, when Duel says to, as
+# for a merge request: only where a regression in a push passes (see
+# c.fail_on), so the comment says what the check doesn't. Its last comment
+# is the commit before's.
+<%= gitlab_job %>:commit-comment:
+  image: alpine:3
+  stage: .post
+  needs: [<%= gitlab_job %>]
+  rules:
+    - if: $DUEL_TOKEN && $CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+      when: always
+  variables:
+    GIT_STRATEGY: none # it runs none of the code
+  script:
+    - apk add --no-cache --quiet curl jq
+    - |
+      case "$DUEL_COMMENT" in post|change) ;; *) exit 0 ;; esac
+      report=<%= working_directory ? "#{working_directory}/" : "" %>duel.md
+      [ -f "$report" ] || exit 0
+      api="$CI_API_V4_URL/projects/$CI_PROJECT_ID"
+      token="PRIVATE-TOKEN: $DUEL_TOKEN"
+      marker="<!-- <%= marker %>"
+      me=$(curl -sf -H "$token" "$CI_API_V4_URL/user" | jq .id)
+      last=$(curl -sf -H "$token" "$api/repository/commits/$CI_COMMIT_BEFORE_SHA/comments?per_page=100" |
+        jq -r --argjson me "$me" --arg marker "$marker status=" '.[] | select(.author.id == $me) | .note | split("\n")[0] | rtrimstr("\r") | select(startswith($marker))' | tail -n 1)
+      if [ "$DUEL_COMMENT" = post ] || { [ -n "$last" ] && [ "$last" != "$marker status=$DUEL_STATUS -->" ]; }; then
+        { echo "$marker status=$DUEL_STATUS -->"; cat "$report"; } | jq -Rs '{note: .}' |
+          curl -sf -H "$token" -H "Content-Type: application/json" --data @- "$api/repository/commits/$CI_COMMIT_SHA/comments" > /dev/null
+      fi
+
+# With c.push_base = :last_passed in .duel.rb, a push is compared with the
+# last commit Duel passed, which a branch marks (<%= passed_branch %>/main for
+# main), so slowdowns too small for any one push to fail add up until they
+# fail one. This job moves the branch to a push that passed (or makes it).
+# To accept a regression, move the branch yourself (for main, git push
+# origin main:<%= passed_branch %>/main).
+<%= gitlab_job %>:passed:
+  image: alpine:3
+  stage: .post
+  needs: [<%= gitlab_job %>]
+  rules:
+    - if: $DUEL_TOKEN && $CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  variables:
+    GIT_STRATEGY: none # it runs none of the code
+  script:
+    - apk add --no-cache --quiet curl
+    - |
+      [ "$DUEL_PASSED" = true ] || exit 0
+      api="$CI_API_V4_URL/projects/$CI_PROJECT_ID"
+      token="PRIVATE-TOKEN: $DUEL_TOKEN"
+      branch="<%= passed_branch %>/$CI_COMMIT_BRANCH"
+      curl -s -o /dev/null -H "$token" -X DELETE "$api/repository/branches/$(echo "$branch" | sed 's|/|%2F|g')"
+      curl -sf -o /dev/null -H "$token" --data-urlencode "branch=$branch" --data-urlencode "ref=$CI_COMMIT_SHA" "$api/repository/branches"

data/lib/duel/templates/duel.rb.erb

@@ -37,4 +37,17 @@ Duel.configure do |c|
   # :results (passed or failed), :failures (failed, or couldn't compare),
   # or :never.
   # c.comment = :failures
+
+  # Which runs a regression fails: :every_run, or :pull_requests, for a
+  # project where people push to main directly (on GitHub Actions, another
+  # run warns and passes, and a pushed commit gets the comment instead).
+  # c.fail_on = :every_run
+
+  # A label that accepts a regression in a pull request (nil for none).
+  # c.accept_label = "duel: accept"
+
+  # What the workflow compares a push with: :before (the commit before it),
+  # or :last_passed (the last commit Duel passed, which a branch,
+  # duel/passed/main, marks), so small slowdowns add up until they fail.
+  # c.push_base = :before
 end

data/lib/duel/templates/perf-comment.yml.erb

@@ -0,0 +1,59 @@
+name: Perf comment<%= " (#{working_directory})" if working_directory %>
+
+# Duel's report, as a new comment on the pull request, when Duel says to:
+# always (post), or only when its last comment's status differs from the
+# run's (change), so the latest comment is never stale. It never edits or
+# deletes a comment. It runs once the Perf workflow has, with this
+# repository's own workflow and a token that can write, so a pull request
+# from a fork gets a comment too. It checks nothing out and runs none of
+# the pull request's code, and of what the Duel job kept (where that code
+# ran), it trusts only what that job could have said: the pull request's
+# number, if it names the pull request the run compared, and the comment
+# and the status, if they're ones Duel says. (The workflow must be on the
+# default branch before it runs at all.)
+on:
+  workflow_run:
+    workflows: ["Perf<%= " (#{working_directory})" if working_directory %>"]
+    types: [completed]
+
+permissions: {}
+
+jobs:
+  comment:
+    name: Comment
+    if: ${{ github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion != 'cancelled' }}
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read # to get the report from the Perf run
+      pull-requests: write # to comment on the pull request with the report
+    steps:
+      - name: Get the report
+        id: report
+        continue-on-error: true # there's none when the Duel job failed before comparing
+        uses: actions/download-artifact@v8
+        with:
+          name: duel-report
+          path: ${{ runner.temp }}/report
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ github.token }}
+      - name: Comment on the pull request
+        if: steps.report.outcome == 'success'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
+        run: |
+          said() { grep -xE "$1=($2)" "$RUNNER_TEMP/report/comment.env" | tail -n 1 | cut -d= -f2; }
+          PR=$(said pr '[0-9]+')
+          COMMENT=$(said comment 'post|change')
+          STATUS=$(said status 'passed|failed|neutral')
+          [ -n "$PR" ] && [ -n "$COMMENT" ] && [ -n "$STATUS" ] || exit 0
+          [ "$(gh api "repos/$GITHUB_REPOSITORY/pulls/$PR" --jq .head.sha)" = "$HEAD_SHA" ] || exit 0
+          marker="<!-- <%= marker %>"
+          # The first line of the last comment Duel posted here: its marker,
+          # with its status (none in Duel 0.1.0's, which counts as another).
+          last=$(gh api --paginate "repos/$GITHUB_REPOSITORY/issues/$PR/comments" \
+            --jq ".[] | select(.user.login == \"github-actions[bot]\") | .body | split(\"\n\")[0] | rtrimstr(\"\r\") | select(startswith(\"$marker status=\") or . == \"$marker -->\")" | tail -n 1)
+          if [ "$COMMENT" = post ] || { [ -n "$last" ] && [ "$last" != "$marker status=$STATUS -->" ]; }; then
+            { echo "$marker status=$STATUS -->"; cat "$RUNNER_TEMP/report/duel.md"; } > "$RUNNER_TEMP/comment.md"
+            gh api --method POST "repos/$GITHUB_REPOSITORY/issues/$PR/comments" -F body=@"$RUNNER_TEMP/comment.md" > /dev/null
+          fi

data/lib/duel/templates/perf.yml.erb

@@ -1,27 +1,40 @@
-name: Perf
+name: Perf<%= " (#{working_directory})" if working_directory %>
 
 on:
   pull_request:
+  merge_group: # (a merge queue's)
   push:
-    branches: [main]
+    branches: [main] # (and any other branch to guard, a stable one, say)
   schedule:
     - cron: "0 4 * * *"
   workflow_dispatch:
 
+# A pull request's newer push cancels its run, if that's still going, as
+# only its newest commit's result counts. Every other run (a push's, say)
+# runs to the end, so that each push is compared.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 # The Duel job runs the branch's code (its benchmarks too), so it only
-# reads. Commenting is the Comment job's, which runs none of it.
+# reads. Commenting on a commit is the Comment on the commit job's, which
+# runs none of it, and commenting on a pull request is the Perf comment
+# workflow's.
 permissions:
   contents: read
+  pull-requests: read # for the pull request's labels (see c.accept_label)
 
 jobs:
   duel:
     name: Duel
     runs-on: ubuntu-latest
-    # Whether the Comment job comments (post, change or none), and the
-    # run's status (passed, failed or neutral), from Duel.
+    # Whether to comment (post, change or none), the run's status (passed,
+    # failed or neutral), and whether to mark a push passed (true, or
+    # nothing), from Duel.
     outputs:
       comment: ${{ steps.compare.outputs.comment }}
       status: ${{ steps.compare.outputs.status }}
+      passed: ${{ steps.compare.outputs.passed }}
 <% if working_directory -%>
     # The project is in a subdirectory of the repository: Duel runs there,
     # and checks out the whole repository for the baseline.
@@ -40,20 +53,27 @@ jobs:
       # .duel.rb). When the baseline's names another Ruby than this code's,
       # that one is installed too, and linked where Duel finds it (as
       # chruby would), before the project's own Ruby, which runs Duel. The
-      # baseline is the Compare step's: where HEAD left the main branch
-      # (for a pull request, and run by hand), the commit before a push, or
-      # on a schedule the last release, the newest tag before HEAD that
-      # RELEASE_TAGS matches. (If .duel.rb sets c.main_branch or
-      # c.release_tags, set MAIN_BRANCH or RELEASE_TAGS to match.)
+      # baseline is the Compare step's: where HEAD left the branch a pull
+      # request targets (or run by hand, the main branch), a merge queue's
+      # base, the commit before a push (or the last commit Duel passed, PASSED, if there is
+      # one: see the Mark the commit passed job), or on a schedule the last
+      # release, the newest tag before HEAD that RELEASE_TAGS matches. (If
+      # .duel.rb sets c.main_branch or c.release_tags, set MAIN_BRANCH or
+      # RELEASE_TAGS to match.)
       - name: Find the baseline's Ruby
         id: baseline
         env:
           BEFORE: ${{ github.event.before }}
-          MAIN_BRANCH: origin/${{ github.event.repository.default_branch }}
+          QUEUE_BASE: ${{ github.event.merge_group.base_sha }}
+          PASSED: origin/<%= passed_branch %>/${{ github.ref_name }}
+          MAIN_BRANCH: origin/${{ github.base_ref || github.event.repository.default_branch }}
           RELEASE_TAGS: "<%= release_tags %>"
         run: |
           case "$GITHUB_EVENT_NAME" in
-            push) base=$BEFORE ;;
+            push)
+              base=$BEFORE
+              if git merge-base --is-ancestor "$PASSED" HEAD 2>/dev/null; then base=$PASSED; fi ;;
+            merge_group) base=$QUEUE_BASE ;;
             schedule) base=$(git describe --tags --abbrev=0 --match "$RELEASE_TAGS" HEAD^ 2>/dev/null) || base= ;;
             *) base=$(git merge-base HEAD "$MAIN_BRANCH" 2>/dev/null) || base= ;;
           esac
@@ -93,50 +113,80 @@ jobs:
           ruby-version: "<%= ruby_version %>"
 <% end -%>
           bundler-cache: true
-      # Against the main branch for a pull request, what was there before
-      # for a push, and the last release on a schedule (slow creep). Duel
-      # adds its report to the job's summary, writes it to duel.md for the
-      # comment, and sets the step's outputs to say whether to comment, as
-      # c.comment in .duel.rb says, whatever the outcome.
+      # The labels of the pull request (or for a push, of the one that
+      # merged it), for c.accept_label in .duel.rb, as a JSON array. They're
+      # read as the job runs, so after adding the label, run it again.
+      - name: Find the pull request's labels
+        id: labels
+        if: github.event_name == 'pull_request' || github.event_name == 'merge_group' || github.event_name == 'push'
+        continue-on-error: true # (without them, nothing's accepted)
+        env:
+          GH_TOKEN: ${{ github.token }}
+          PR: ${{ github.event.pull_request.number }}
+          QUEUED: ${{ github.event.merge_group.head_ref }}
+        run: |
+          # (In a merge queue, the last pull request queued, which the queue's
+          # branch names: gh-readonly-queue/main/pr-123-<sha>.)
+          if [ -n "$QUEUED" ]; then
+            PR=${QUEUED##*/pr-}
+            PR=${PR%%-*}
+          fi
+          if [ -n "$PR" ]; then
+            labels=$(gh api "repos/$GITHUB_REPOSITORY/issues/$PR/labels" --jq '[.[].name]')
+          else
+            labels=$(gh api "repos/$GITHUB_REPOSITORY/commits/$GITHUB_SHA/pulls" --jq '[.[0].labels[]?.name]')
+          fi
+          echo "labels=$labels" >> "$GITHUB_OUTPUT"
+      # Against the branch it targets for a pull request, the queue's base
+      # for a merge queue, what was there before for a push (or as
+      # c.push_base in .duel.rb says, the last commit Duel passed), and the
+      # last release on a schedule (slow creep). Duel adds its report to
+      # the job's summary, writes it to duel.md for the comment, and sets
+      # the step's outputs to say whether to comment, as c.comment in
+      # .duel.rb says, whatever the outcome.
       - name: Compare
         id: compare
         env:
-          DUEL_BASE: ${{ github.event_name == 'schedule' && 'last-release' || github.event_name == 'push' && github.event.before || '' }}
+          DUEL_BASE: ${{ github.event_name == 'schedule' && 'last-release' || github.event_name == 'push' && github.event.before || github.event_name == 'merge_group' && github.event.merge_group.base_sha || '' }}
           # (Run by hand, it compares anyway: with nothing changed, the code
           # with itself, which checks the setup.)
           DUEL_FORCE: ${{ github.event_name == 'workflow_dispatch' && '1' || '' }}
+          DUEL_LABELS: ${{ steps.labels.outputs.labels }}
+        run: bundle exec duel --markdown "$RUNNER_TEMP/duel/duel.md"
+      # For a pull request, what Duel said, for the Perf comment workflow,
+      # which can't see this job's outputs.
+      - name: Say whether to comment
+        if: ${{ !cancelled() && github.event_name == 'pull_request' }}
+        env:
+          PR: ${{ github.event.pull_request.number }}
+          COMMENT: ${{ steps.compare.outputs.comment }}
+          STATUS: ${{ steps.compare.outputs.status }}
         run: |
-          # (A branch's first push, or one that rewrote history, has no
-          # commit before it here to compare against.)
-          if [ "$GITHUB_EVENT_NAME" = push ] && ! git cat-file -e "$DUEL_BASE^{commit}" 2>/dev/null; then
-            echo "::notice::No commit before this push to compare against"
-            exit 0
-          fi
-          bundle exec duel --markdown "$RUNNER_TEMP/duel.md"
-      # The report, for the Comment job.
+          mkdir -p "$RUNNER_TEMP/duel"
+          printf 'pr=%s\ncomment=%s\nstatus=%s\n' "$PR" "$COMMENT" "$STATUS" > "$RUNNER_TEMP/duel/comment.env"
+      # The report, for the comments.
       - name: Keep the report
-        if: ${{ !cancelled() && github.event_name == 'pull_request' }}
+        if: ${{ !cancelled() && (github.event_name == 'pull_request' || github.event_name == 'push') }}
         uses: actions/upload-artifact@v7
         with:
           name: duel-report
-          path: ${{ runner.temp }}/duel.md
+          path: ${{ runner.temp }}/duel/
           if-no-files-found: ignore # none when Duel didn't get to compare
           retention-days: 1
 
-  # The report, as a new comment on the pull request, when Duel says to:
-  # always (post), or only when its last comment's status differs from
-  # this run's (change), so the latest comment is never stale. It never
-  # edits or deletes a comment. This job checks nothing out and runs none
-  # of the branch's code, so it alone can write. (A pull request from a
-  # fork gets no comment, as its token can't write one: the Duel job's
-  # summary has the report.)
-  comment:
-    name: Comment
+  # The report, as a new comment on a pushed commit, which notifies its
+  # author, when Duel says to, as for a pull request (see the Perf comment
+  # workflow). It does only where a regression in a push passes, with
+  # c.fail_on = :pull_requests in .duel.rb, so the comment says what the
+  # check doesn't. Its last comment is the last one on any commit. This
+  # job checks nothing out and runs none of the code.
+  commit-comment:
+    name: Comment on the commit
     needs: duel
-    if: ${{ !cancelled() && github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository && (needs.duel.outputs.comment == 'post' || needs.duel.outputs.comment == 'change') }}
+    if: ${{ !cancelled() && github.event_name == 'push' && (needs.duel.outputs.comment == 'post' || needs.duel.outputs.comment == 'change') }}
     runs-on: ubuntu-latest
     permissions:
-      pull-requests: write # to comment on the pull request with the report
+      contents: write # to comment on the commit with the report
     steps:
       - name: Get the report
         id: report
@@ -145,20 +195,40 @@ jobs:
         with:
           name: duel-report
           path: ${{ runner.temp }}/report
-      - name: Comment on the pull request
+      - name: Comment on the commit
         if: steps.report.outcome == 'success'
         env:
           GH_TOKEN: ${{ github.token }}
-          PR: ${{ github.event.pull_request.number }}
           COMMENT: ${{ needs.duel.outputs.comment }}
           STATUS: ${{ needs.duel.outputs.status }}
         run: |
           marker="<!-- <%= marker %>"
-          # The first line of the last comment Duel posted here: its marker,
-          # with its status (none in Duel 0.1.0's, which counts as another).
-          last=$(gh api --paginate "repos/$GITHUB_REPOSITORY/issues/$PR/comments" \
-            --jq ".[] | select(.user.login == \"github-actions[bot]\") | .body | split(\"\n\")[0] | rtrimstr(\"\r\") | select(startswith(\"$marker status=\") or . == \"$marker -->\")" | tail -n 1)
+          last=$(gh api --paginate "repos/$GITHUB_REPOSITORY/comments" \
+            --jq ".[] | select(.user.login == \"github-actions[bot]\") | .body | split(\"\n\")[0] | rtrimstr(\"\r\") | select(startswith(\"$marker status=\"))" | tail -n 1)
           if [ "$COMMENT" = post ] || { [ -n "$last" ] && [ "$last" != "$marker status=$STATUS -->" ]; }; then
             { echo "$marker status=$STATUS -->"; cat "$RUNNER_TEMP/report/duel.md"; } > "$RUNNER_TEMP/comment.md"
-            gh api --method POST "repos/$GITHUB_REPOSITORY/issues/$PR/comments" -F body=@"$RUNNER_TEMP/comment.md" > /dev/null
+            gh api --method POST "repos/$GITHUB_REPOSITORY/commits/$GITHUB_SHA/comments" -F body=@"$RUNNER_TEMP/comment.md" > /dev/null
           fi
+
+  # With c.push_base = :last_passed in .duel.rb, a push is compared with
+  # the last commit Duel passed, which a branch marks (each branch pushed
+  # has its own), so slowdowns too small for any one push to fail add up
+  # until they fail one. This job moves the branch to a push that passed
+  # (or makes it). It checks nothing out and runs none of the code. To
+  # accept a regression, move the branch yourself (for main, git push
+  # origin main:<%= passed_branch %>/main).
+  passed:
+    name: Mark the commit passed
+    needs: duel
+    if: ${{ !cancelled() && github.event_name == 'push' && needs.duel.outputs.passed == 'true' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # to move the branch
+    steps:
+      - name: Move the branch to the commit
+        env:
+          GH_TOKEN: ${{ github.token }}
+          BRANCH: <%= passed_branch %>/${{ github.ref_name }}
+        run: |
+          gh api --method PATCH "repos/$GITHUB_REPOSITORY/git/refs/heads/$BRANCH" -f sha="$GITHUB_SHA" -F force=true > /dev/null 2>&1 ||
+            gh api --method POST "repos/$GITHUB_REPOSITORY/git/refs" -f ref="refs/heads/$BRANCH" -f sha="$GITHUB_SHA" > /dev/null

data/lib/duel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Duel
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/sig/duel/baseline.rbs

@@ -13,9 +13,17 @@ module Duel
 
     def initialize: (Config config, Settings settings) -> void
 
-    # 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.
     def ref: () -> String?
 
+    # The branch that marks the last commit Duel passed in a push to the
+    # branch pushed.
+    def passed_branch: () -> String
+
+    # The last commit Duel passed in a push, as checked out (on origin).
+    def passed: () -> String
+
     # Whether nothing #watched changed since the baseline.
     def unchanged?: () -> bool
 
@@ -62,6 +70,11 @@ module Duel
     # says why there's none.
     def merge_base: () -> String
 
+    # A push's baseline: the last commit Duel passed, where
+    # Config#push_base says and HEAD has it, or else the commit before the
+    # push, or nil where that isn't here.
+    def pushed: () -> String?
+
     # Whether +dir+ is a checkout of this repository.
     def ours?: (String dir) -> bool
 

data/sig/duel/cli.rbs

@@ -28,6 +28,15 @@ module Duel
     # A run's status as the comment's marker has it.
     MARKED: Hash[String, String]
 
+    # The GitHub Actions events of a pull request.
+    PULL_REQUESTS: Array[String]
+
+    # The exit status of a run that was slower, but warned, on GitLab CI.
+    WARNED: Integer
+
+    # Where else to write the step's outputs, as variables.
+    OUTPUT: String
+
     # The variables that set options, to their options.
     ENV_OPTIONS: Hash[String, String]
 
@@ -43,6 +52,8 @@ module Duel
     @json: String?
     @settings: Settings?
     @config: Config?
+    @passed: bool?
+    @note: String?
 
     def initialize: (Array[String] argv, ?env: _Env, ?out: _Output, ?err: _Output) -> void
 
@@ -61,6 +72,13 @@ module Duel
     # The mode --comment names, or an invalid argument.
     def self.comment_mode: (String name) -> Config::comment
 
+    # The runs --fail-on names, or an invalid argument.
+    def self.fail_on: (String name) -> Config::fail_on
+
+    # Which of +values+ an option's argument names, or an invalid
+    # argument.
+    def self.named: [T < Symbol] (String name, Array[T] values) -> T
+
     def parse: () -> Settings
 
     private
@@ -68,14 +86,58 @@ module Duel
     # What #run does, holding the project's lock.
     def compare: (Config config, Settings settings) -> Integer
 
+    # The exit status of a run that was slower: 1, or 0 where only a pull
+    # request fails, outside one.
+    def slower: (Config config, Settings settings) -> Integer
+
+    # Passes a run that was slower, with a warning and a note.
+    def passing: (String why, String note, ?Integer exit) -> Integer
+
+    # Whether the pull request's labels have the one that accepts a
+    # regression.
+    def accepted?: (Config config) -> bool
+
+    # The pull request's labels, from DUEL_LABELS.
+    def labels: () -> Array[untyped]
+
+    # Whether the workflow marks a push that passed as the last commit
+    # Duel passed.
+    def marks_passed?: (Config config, Settings settings) -> bool
+
+    # What a run on CI is for, as GitHub Actions names it, or nil outside
+    # CI.
+    def event: () -> String?
+
+    # Whether this is a run on GitLab CI.
+    def gitlab?: () -> bool
+
+    # The first of the variables +names+ that's set, or nil.
+    def variable: (*String names) -> String?
+
+    # Whether a regression fails only a pull request.
+    def pull_requests_only?: (Config config, Settings settings) -> bool
+
+    # Whether this is a run on GitHub Actions for something other than a
+    # pull request.
+    def outside_pull_request?: () -> bool
+
+    # Whether this is a run on GitHub Actions for a pull request.
+    def pull_request?: () -> bool
+
+    # Whether the baseline is a merge queue's base.
+    def queued?: (Settings settings) -> bool
+
+    # Whether this is a run on GitHub Actions for a push.
+    def pushed?: () -> bool
+
     # Says there's nothing to compare, and why, and passes.
     def nothing: (String title, String why) -> Integer
 
     # Reports a run that didn't compare, and why, and returns +exit+.
     def unfinished: (String mark, String title, String status, String why, Integer exit) -> Integer
 
-    # What the workflow does about its comment on a pull request, for a
-    # run of +status+.
+    # What the workflow does about its comment on a pull request, or on a
+    # pushed commit, for a run of +status+.
     def commenting: (String status) -> String
 
     # Writes the reports where they're asked for, each made only if it's