pr-report-core 0.1.0 → 0.2.0

package/src/queue-order.test.mts

@@ -383,15 +383,52 @@ describe(orderCandidates, () => {
       [2, 3, 1],
     );
   });
+
+  // Picked early, it is released, goes green and is set aside for a person,
+  // and the cycle it took went to nothing that could merge on its own.
+  test('puts one only a bypass merges with priority:low, unless labelled priority:high', () => {
+    assert.deepStrictEqual(
+      order(
+        [
+          facts({ number: 1 }),
+          facts({
+            number: 2,
+            labels: [
+              MERGE_QUEUED_LABEL,
+              PRIORITY_HIGH_LABEL,
+              PRIORITY_LOW_LABEL,
+            ],
+          }),
+          facts({
+            number: 3,
+            labels: [MERGE_QUEUED_LABEL, PRIORITY_LOW_LABEL],
+          }),
+          facts({ number: 4, headRef: 'changeset-release/main' }),
+          facts({ number: 5, mergeState: 'DIRTY' }),
+          facts({ number: 6 }),
+          facts({ number: 7 }),
+          facts({
+            number: 8,
+            labels: [MERGE_QUEUED_LABEL, PRIORITY_HIGH_LABEL],
+          }),
+        ],
+        [7],
+        [1, 2, 7, 8],
+      ),
+      [8, 6, 5, 4, 1, 2, 3, 7],
+    );
+  });
 });
 
 const order = (
   candidates: readonly QueueFacts[],
   demoted: readonly number[] = [],
+  bypass: readonly number[] = [],
 ): readonly number[] =>
   orderCandidates(candidates, (candidate) => candidate, {
     defaultBranch: 'main',
     demoted: (candidate) => demoted.includes(candidate.number),
+    bypass: (candidate) => bypass.includes(candidate.number),
   }).map(({ number }) => number);
 
 const facts = (

package/src/queue-owner.mts

@@ -64,87 +64,6 @@ export const SET_ASIDE_REASONS = [
 
 export type SetAsideReason = (typeof SET_ASIDE_REASONS)[number];
 
-/**
- * Whose a pull request set aside for `reason` is, while the comment stands
- * at its head. A skill's reason is one a session can fix by pushing: a
- * conflict to resolve, a failure to reproduce. A person's is one only a
- * setting, a permission, a review or a merge by hand clears, and the comment
- * says which. A `switch` with no default, so a reason added to
- * {@link SET_ASIDE_REASONS} without an owner fails to compile.
- */
-const setAsideOwner = (
-  reason: SetAsideReason,
-): Readonly<{ owner: 'human' | 'skill'; why: string }> => {
-  switch (reason) {
-    case 'checks-failed':
-    case 'rebase-failed':
-      return { owner: 'skill', why: 'the skill fixes it' };
-
-    case 'already-in-base':
-      return {
-        owner: 'human',
-        why: 'every commit is already in the base; close it',
-      };
-
-    case 'arm-failed':
-      return {
-        owner: 'human',
-        why: 'auto-merge could not be armed; a setting or a permission holds it',
-      };
-
-    case 'awaiting-bypass':
-      return {
-        owner: 'human',
-        why: 'green, and only a ruleset bypass merges it',
-      };
-
-    case 'not-merging':
-      return {
-        owner: 'human',
-        why: 'green but not merging; something the worker cannot read holds it',
-      };
-
-    case 'push-failed':
-      return {
-        owner: 'human',
-        why: 'the push was refused; a setting or a permission holds it',
-      };
-
-    case 'unlabel-failed':
-      return {
-        owner: 'human',
-        why: '`skip-ci` could not be taken off; a permission holds it',
-      };
-
-    case 'watch-timeout':
-      return {
-        owner: 'human',
-        why: 'its checks ran past the watch; look at the run',
-      };
-  }
-};
-
-/** What {@link queueOwner} reads about one pull request. */
-export type QueueOwnerInput = Readonly<{
-  number: number;
-  labels: readonly string[];
-  isDraft: boolean;
-  fromFork: boolean;
-  headRef: string;
-  headSha: string;
-  baseRef: string;
-  defaultBranch: string;
-  /** The open pull request whose branch this one is on, if any. */
-  stackedOn: number | undefined;
-  /** Whether it sits on a `Merge-After` cycle. */
-  inCycle: boolean;
-  /** This account's set-aside comment on it (`set-aside.mts`). */
-  setAside: SetAsideComment | undefined;
-  /** This account's claim comment on it (`claim.mts`). */
-  claim: ClaimComment | undefined;
-  nowEpochMs: number;
-}>;
-
 /**
  * Who moves `pr` next, or `undefined` for a pull request the queue does not
  * cover: neither `merge-queued` nor `auto-rebase` under `skip-ci`.
@@ -250,6 +169,90 @@ export const queueOwnerOfEntry = (
     nowEpochMs: context.nowEpochMs,
   });
 
+export const isSetAsideReason = (reason: string): reason is SetAsideReason =>
+  KNOWN_REASONS.has(reason);
+
+/**
+ * Whose a pull request set aside for `reason` is, while the comment stands
+ * at its head. A skill's reason is one a session can fix by pushing: a
+ * conflict to resolve, a failure to reproduce. A person's is one only a
+ * setting, a permission, a review or a merge by hand clears, and the comment
+ * says which. A `switch` with no default, so a reason added to
+ * {@link SET_ASIDE_REASONS} without an owner fails to compile.
+ */
+const setAsideOwner = (
+  reason: SetAsideReason,
+): Readonly<{ owner: 'human' | 'skill'; why: string }> => {
+  switch (reason) {
+    case 'checks-failed':
+    case 'rebase-failed':
+      return { owner: 'skill', why: 'the skill fixes it' };
+
+    case 'already-in-base':
+      return {
+        owner: 'human',
+        why: 'every commit is already in the base; close it',
+      };
+
+    case 'arm-failed':
+      return {
+        owner: 'human',
+        why: 'auto-merge could not be armed; a setting or a permission holds it',
+      };
+
+    case 'awaiting-bypass':
+      return {
+        owner: 'human',
+        why: 'green, and only a ruleset bypass merges it',
+      };
+
+    case 'not-merging':
+      return {
+        owner: 'human',
+        why: 'green but not merging; something the worker cannot read holds it',
+      };
+
+    case 'push-failed':
+      return {
+        owner: 'human',
+        why: 'the push was refused; a setting or a permission holds it',
+      };
+
+    case 'unlabel-failed':
+      return {
+        owner: 'human',
+        why: '`skip-ci` could not be taken off; a permission holds it',
+      };
+
+    case 'watch-timeout':
+      return {
+        owner: 'human',
+        why: 'its checks ran past the watch; look at the run',
+      };
+  }
+};
+
+/** What {@link queueOwner} reads about one pull request. */
+export type QueueOwnerInput = Readonly<{
+  number: number;
+  labels: readonly string[];
+  isDraft: boolean;
+  fromFork: boolean;
+  headRef: string;
+  headSha: string;
+  baseRef: string;
+  defaultBranch: string;
+  /** The open pull request whose branch this one is on, if any. */
+  stackedOn: number | undefined;
+  /** Whether it sits on a `Merge-After` cycle. */
+  inCycle: boolean;
+  /** This account's set-aside comment on it (`set-aside.mts`). */
+  setAside: SetAsideComment | undefined;
+  /** This account's claim comment on it (`claim.mts`). */
+  claim: ClaimComment | undefined;
+  nowEpochMs: number;
+}>;
+
 /**
  * The set-aside `comment` says, if it stands at `headSha` with no retry
  * asked for. The base is not read: see the module comment.
@@ -264,9 +267,6 @@ const standingAt = (
     ? comment.setAside
     : undefined;
 
-export const isSetAsideReason = (reason: string): reason is SetAsideReason =>
-  KNOWN_REASONS.has(reason);
-
 const KNOWN_REASONS: ReadonlySet<string> = new Set(SET_ASIDE_REASONS);
 
 /**

package/src/report.mts

@@ -82,49 +82,6 @@ export const buildReport = ({
     issuesLimit,
   }) as const;
 
-/**
- * Each open issue with how it stands for being started
- * (`docs/issue-start-after.md`): its start state, or how far someone has
- * got with it when it is startable (`progressOf`), and where each thing it
- * names stands.
- */
-const reportIssues = (
-  issues: readonly OpenIssue[],
-  pulls: readonly PullRequestFacts[],
-  references: ReadonlyMap<number, ReferenceStatus>,
-): readonly ReportIssue[] => {
-  const listed = new Set(issues.map(({ number }) => number));
-
-  const open = new Set(pulls.map(({ number }) => number));
-
-  const statusOf = (number: number): ReferenceStatus =>
-    listed.has(number) || open.has(number)
-      ? 'waiting'
-      : (references.get(number) ?? 'unknown');
-
-  const states = decideStartStates(issues, statusOf);
-
-  const worked = issuesInProgress(pulls);
-
-  return issues.map((issue) => ({
-    ...issue,
-    start: withProgress(
-      states.get(issue.number) ?? 'free',
-      progressOf(issue.labels, worked.has(issue.number)),
-    ),
-    named: issue.startAfter.map((number) => ({
-      number,
-      status: statusOf(number),
-    })),
-  }));
-};
-
-export type DecidedEntries = Readonly<{
-  entries: readonly ReportEntry[];
-  roots: readonly TreeNode[];
-  cycles: readonly (readonly number[])[];
-}>;
-
 /**
  * The part of a report that is decided rather than read: each open pull
  * request's declared order, the stack it is in, its check verdict, and the
@@ -236,6 +193,49 @@ export const buildEntries = ({
   return { entries, roots, cycles };
 };
 
+/**
+ * Each open issue with how it stands for being started
+ * (`docs/issue-start-after.md`): its start state, or how far someone has
+ * got with it when it is startable (`progressOf`), and where each thing it
+ * names stands.
+ */
+const reportIssues = (
+  issues: readonly OpenIssue[],
+  pulls: readonly PullRequestFacts[],
+  references: ReadonlyMap<number, ReferenceStatus>,
+): readonly ReportIssue[] => {
+  const listed = new Set(issues.map(({ number }) => number));
+
+  const open = new Set(pulls.map(({ number }) => number));
+
+  const statusOf = (number: number): ReferenceStatus =>
+    listed.has(number) || open.has(number)
+      ? 'waiting'
+      : (references.get(number) ?? 'unknown');
+
+  const states = decideStartStates(issues, statusOf);
+
+  const worked = issuesInProgress(pulls);
+
+  return issues.map((issue) => ({
+    ...issue,
+    start: withProgress(
+      states.get(issue.number) ?? 'free',
+      progressOf(issue.labels, worked.has(issue.number)),
+    ),
+    named: issue.startAfter.map((number) => ({
+      number,
+      status: statusOf(number),
+    })),
+  }));
+};
+
+export type DecidedEntries = Readonly<{
+  entries: readonly ReportEntry[];
+  roots: readonly TreeNode[];
+  cycles: readonly (readonly number[])[];
+}>;
+
 const NO_DECLARATIONS: IssueDeclarations = {
   startAfter: new Map<number, readonly number[]>(),
   open: new Set<number>(),