atris 3.75.0 → 3.77.0

package/lib/pull-request-link.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// A pull request link, read the one way everything that compares links reads it. The task store
+// (which pull request a job points at) and the held-job sweep (which pull request GitHub answered
+// for) both use it, so the two cannot disagree about what a link names.
+//
+// The link is https://<host>/<owner>/<name>/pull/<number>, however a person decorated it: a
+// trailing slash, /files, a query string, a fragment, any case. A link with no number, or a number
+// that is not a positive whole number, names no pull request.
+//
+//   repo      the owner and name, in lower case
+//   number    the pull request number
+//   repoLink  the repository's own address, as the link spells it
+
+const PULL_REQUEST_LINK = /^(https?:\/\/[^/\s]+\/([^/\s]+)\/([^/\s]+))\/pull\/(\d+)(?:[/?#]\S*)?$/i;
+
+function pullRequestOfLink(link) {
+  const match = PULL_REQUEST_LINK.exec(String(link || '').trim());
+  if (!match) return null;
+  const number = Number(match[4]);
+  if (!Number.isSafeInteger(number) || number <= 0) return null;
+  return { repo: `${match[2]}/${match[3]}`.toLowerCase(), number, repoLink: match[1] };
+}
+
+module.exports = { pullRequestOfLink };

package/lib/review-integrity.js

@@ -59,20 +59,65 @@ function reviewEventActors(task) {
   return actors;
 }
 
-// Actors who reviewed the task and are not its builder.
+// Everyone who ever built the task: the stamped builder, the current claimant, whoever any claim
+// event on file names, and whoever handed work in on it (the proof_ready events that carry a
+// handed_in_by mark; a review pass leaves none) together with the others that hand-in names as
+// having built the work with it (its built_with list: a flight that ran for a member hands in under
+// the member's name, and the engines that ran are named there). Authorship is cumulative and nothing clears it, so
+// sending a job back, letting the claim go or reopening it never makes a past builder look
+// independent again. The system's own names (RESERVED_ACTORS) record passes and checks, never
+// builds, so an event under one of them makes no author. `task.events` is whatever the caller has
+// of the job's history; a caller with the whole history (the store's authorsOfTask) gets the whole
+// answer.
+function taskAuthors(task) {
+  const authors = new Set();
+  if (!task || typeof task !== 'object') return authors;
+  const add = (value, { fromEvent = false } = {}) => {
+    const name = normalizeActor(value);
+    if (name && !(fromEvent && RESERVED_ACTORS.has(name))) authors.add(name);
+  };
+  const metadata = task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  add(metadata.built_by);
+  add(task.claimed_by);
+  const events = Array.isArray(task.events) ? task.events : [];
+  for (const event of events) {
+    if (!event || typeof event !== 'object') continue;
+    const payload = event.payload && typeof event.payload === 'object' ? event.payload : {};
+    if (event.event_type === 'claimed') add(payload.claimed_by || event.actor, { fromEvent: true });
+    else if (event.event_type === 'proof_ready') {
+      add(payload.handed_in_by, { fromEvent: true });
+      // A list of names, not a string to split; anything in it that is not a name is no author.
+      if (Array.isArray(payload.built_with)) {
+        for (const name of payload.built_with) if (typeof name === 'string') add(name, { fromEvent: true });
+      }
+    }
+  }
+  return authors;
+}
+
+// Whether this actor ever built the task (see taskAuthors), or is the builder the older rules
+// resolve for a row with no other record (taskBuilder).
+function isTaskAuthor(task, actor) {
+  const name = normalizeActor(actor);
+  if (!name || !task || typeof task !== 'object') return false;
+  return taskAuthors(task).has(name) || taskBuilder(task) === name;
+}
+
+// Actors who reviewed the task and never built any of it.
 function independentReviewActors(task) {
   const builder = taskBuilder(task);
   const actors = reviewEventActors(task);
   if (builder) actors.delete(builder);
+  for (const author of taskAuthors(task)) actors.delete(author);
   return actors;
 }
 
-// True when at least one review pass came from someone other than the
-// builder. When the builder cannot be resolved at all, fall back to
-// requiring two distinct actors. Independence cannot be proven from one.
+// True when at least one review pass came from someone who never built any of the task. When
+// nobody can be resolved as its builder at all, fall back to requiring two distinct actors.
+// Independence cannot be proven from one.
 function hasIndependentReview(task) {
   const builder = taskBuilder(task);
-  if (!builder) return reviewEventActors(task).size >= 2;
+  if (!builder && taskAuthors(task).size === 0) return reviewEventActors(task).size >= 2;
   return independentReviewActors(task).size >= 1;
 }
 
@@ -138,6 +183,8 @@ module.exports = {
   normalizeActor,
   isFleetEngineActor,
   taskBuilder,
+  taskAuthors,
+  isTaskAuthor,
   reviewEventActors,
   independentReviewActors,
   hasIndependentReview,