@mui/internal-code-infra 0.1.1-canary.2 → 0.1.1-canary.20

package/src/utils/git.mjs

@@ -9,68 +9,63 @@ import gitUrlParse from 'git-url-parse';
  */
 
 /**
- * Get current repository info from git remote
+ * The repository a remote URL points at, if it is a GitHub repository under `mui`.
+ * @param {string} url
+ * @returns {{ owner: string, repo: string } | null}
+ */
+function muiRepositoryOf(url) {
+  try {
+    const parsed = gitUrlParse(url);
+    return parsed.source === 'github.com' && parsed.owner === 'mui'
+      ? { owner: parsed.owner, repo: parsed.name }
+      : null;
+  } catch {
+    // Not a URL git-url-parse understands, such as a local path: not a mui repository either.
+    return null;
+  }
+}
+
+/**
+ * The canonical repository's remote, as opposed to a fork's: `upstream`, else `origin`, each only if
+ * it points at a mui repository. Reads the configured URLs, which `insteadOf` does not rewrite.
  * @param {string} [cwd=process.cwd()]
- * @returns {Promise<RepoInfo>} Repository owner and name
+ * @returns {Promise<RepoInfo>}
  */
 export async function getRepositoryInfo(cwd = process.cwd()) {
-  /**
-   * @type {Record<string, string>}
-   */
-  const cause = {};
-  const { stdout } = await $({ cwd })`git remote -v`;
-  const lines = stdout.trim().split('\n');
-  /**
-   * @type {Set<string>}
-   */
-  const repoRemotes = new Set();
-  /**
-   * @type {Map<string, { owner: string, repo: string }>}
-   */
-  const validRemotes = new Map();
-
-  for (const line of lines) {
-    // Match pattern: "remoteName url (fetch|push)"
-    const [remoteName, url, type] = line.trim().split(/\s+/, 3);
-    repoRemotes.add(remoteName);
-    if (type === '(fetch)') {
-      try {
-        const parsed = gitUrlParse(url);
-        if (parsed.source !== 'github.com' || parsed.owner !== 'mui') {
-          cause[remoteName] = `Remote is not a GitHub repository under 'mui' organization: ${url}`;
-          continue;
-        }
-        if (!validRemotes.has(remoteName)) {
-          validRemotes.set(remoteName, { owner: parsed.owner, repo: parsed.name });
-        }
-      } catch (error) {
-        cause[remoteName] = `Failed to parse URL for remote ${remoteName}: ${url}`;
-      }
-    } else if (type !== '(push)') {
-      throw new Error(`Unexpected line format for "git remote -v": "${line}"`);
-    }
+  // Exits 1 when neither remote is configured; the error below reports that.
+  const { stdout } = await $({
+    cwd,
+    reject: false,
+  })`git config --get-regexp ${'^remote\\.(upstream|origin)\\.url$'}`;
+  /** @type {Map<string, string>} */
+  const urls = new Map();
+  for (const line of stdout.split('\n').filter(Boolean)) {
+    const [key, url] = line.split(' ', 2);
+    urls.set(key.slice('remote.'.length, -'.url'.length), url);
   }
 
-  const preferredOrder = ['upstream', 'origin', ...validRemotes.keys()];
-  for (const name of preferredOrder) {
-    const match = validRemotes.get(name);
-    if (match) {
-      return { ...match, remoteName: name };
+  for (const remoteName of ['upstream', 'origin']) {
+    const url = urls.get(remoteName);
+    const repository = url ? muiRepositoryOf(url) : null;
+    if (repository) {
+      return { ...repository, remoteName };
     }
   }
 
+  const found = [...urls].map(([name, url]) => `${name}: ${url}`).join(', ') || 'none';
   throw new Error(
-    `Failed to find correct remote(s) in : ${Array.from(repoRemotes.keys()).join(', ')}`,
-    { cause },
+    `No canonical remote: neither \`upstream\` nor \`origin\` points at a mui repository (${found}). ` +
+      'Add an `upstream` remote for it, or name the remote explicitly where the command allows it.',
   );
 }
 
 /**
  * Get current git SHA
+ * @param {string} [cwd=process.cwd()]
  * @returns {Promise<string>} Current git commit SHA
  */
-export async function getCurrentGitSha() {
-  const result = await $`git rev-parse HEAD`;
+export async function getCurrentGitSha(cwd = process.cwd()) {
+  const result = await $({ cwd })`git rev-parse HEAD`;
   return result.stdout.trim();
 }
 
@@ -84,3 +79,69 @@ export async function remoteGitTagExists(tagName, cwd = process.cwd()) {
   const { stdout } = await $({ cwd })`git ls-remote --tags origin refs/tags/${tagName}`;
   return stdout.trim().length > 0;
 }
+
+/**
+ * The default branch of `remote`, as the remote itself reports it.
+ * @param {string} remote
+ * @param {string} cwd
+ * @returns {Promise<string>}
+ */
+async function getDefaultBranchOf(remote, cwd) {
+  const { stdout } = await $({ cwd })`git ls-remote --symref ${remote} HEAD`;
+  const match = /^ref: refs\/heads\/(\S+)\tHEAD$/m.exec(stdout);
+  if (!match) {
+    throw new Error(`Remote "${remote}" does not report a default branch.`);
+  }
+  return match[1];
+}
+
+/**
+ * The commit HEAD should be compared against: where it forked from the base branch, or its parent
+ * when HEAD is already on the base branch.
+ * @param {Object} [options]
+ * @param {string} [options.cwd]
+ * @param {string} [options.remote] - Defaults to the canonical remote.
+ * @param {string} [options.baseBranch] - Defaults to the remote's default branch.
+ * @returns {Promise<string>}
+ */
+export async function resolveBaseline(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const remote = options.remote ?? (await getRepositoryInfo(cwd)).remoteName;
+  const baseBranch = options.baseBranch ?? (await getDefaultBranchOf(remote, cwd));
+
+  await $({ cwd })`git fetch --no-tags ${remote} ${baseBranch}`;
+  const [forkPoint, head] = await Promise.all([
+    $({ cwd })`git merge-base HEAD FETCH_HEAD`.then((result) => result.stdout.trim()),
+    getCurrentGitSha(cwd),
+  ]);
+  if (forkPoint !== head) {
+    return forkPoint;
+  }
+
+  const parent = await $({ cwd, reject: false })`git rev-parse --verify HEAD~1`;
+  if (parent.exitCode !== 0) {
+    throw new Error(
+      'HEAD has no parent commit to compare against. A shallow clone is the usual cause.',
+    );
+  }
+  return parent.stdout.trim();
+}
+
+/**
+ * The most recent version tag reachable from HEAD — where a changelog's range starts.
+ * @param {Object} opts
+ * @param {string} opts.cwd
+ * @param {boolean} [opts.fetchAll=true] Whether to fetch all tags from all remotes before finding the latest tag.
+ * @returns {Promise<string>}
+ */
+export async function findLatestTaggedVersion(opts) {
+  const $$ = $({ cwd: opts.cwd });
+  const fetchAll = opts.fetchAll ?? true;
+  if (fetchAll) {
+    // --force to update any existing tags that may have changed to avoid the clobering error.
+    const { remoteName } = await getRepositoryInfo(opts.cwd);
+    await $$`git fetch --tags --force ${remoteName}`;
+  }
+  const { stdout } = await $$`git describe --tags --abbrev=0 --match ${'v*'}`; // only include "version-tags"
+  return stdout.trim();
+}

package/src/utils/github.mjs

@@ -261,3 +261,30 @@ export async function endToEndGhAuthGetToken({ log = false } = {}) {
 export async function clearGitHubAuth() {
   await credentials.deleteKey(GITHUB_APP_CREDENTIAL_KEY);
 }
+
+/**
+ * Returns when a rate-limited request may be retried, or `null` for other errors.
+ * https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api#exceeding-the-rate-limit
+ *
+ * @param {unknown} error
+ * @returns {Date | null}
+ */
+export function getRateLimitRetryTime(error) {
+  const { status, response, message } = /** @type {any} */ (error) ?? {};
+  if (status !== 403 && status !== 429) {
+    return null;
+  }
+  const headers = response?.headers ?? {};
+  const now = Date.now();
+  let retryTime;
+  if (headers['retry-after']) {
+    retryTime = now + Number(headers['retry-after']) * 1000;
+  } else if (headers['x-ratelimit-remaining'] === '0' && headers['x-ratelimit-reset']) {
+    retryTime = Number(headers['x-ratelimit-reset']) * 1000;
+  } else if (/rate limit/i.test(message ?? '')) {
+    retryTime = now;
+  } else {
+    return null;
+  }
+  return new Date(Math.max(retryTime, now + 60_000));
+}

package/vale/styles/MUI/GoogleLatin.yml

@@ -6,6 +6,9 @@ level: error
 nonword: true
 action:
   name: replace
+# Wider than upstream Google.Latin: also catches e.g/eg./i.e/ie. and any trailing
+# punctuation, so no separate rule asks for "e.g." (which this one forbids).
+# The lookbehind skips matches after a dot or inside a word (example.eg).
 swap:
-  '\b(?:eg|e\.g\.)(?=[\s,;])': for example
-  '\b(?:ie|i\.e\.)(?=[\s,;])': that is
+  '(?<![\w.])e\.?g\.?(?=[^\w.]|$)': for example
+  '(?<![\w.])i\.?e\.?(?=[^\w.]|$)': that is

package/vale/styles/MUI/CorrectRererenceCased.yml

@@ -1,14 +0,0 @@
-# Write things correctly, please no wrong references.
-extends: substitution
-message: Use '%s' instead of '%s'
-level: error
-ignorecase: false
-# swap maps tokens in form of bad: good
-# for more information: https://vale.sh/docs/topics/styles/#substitution
-swap:
-  eg: e.g.
-  eg\.: e.g.
-  e\.g: e.g.
-  ie: i.e.
-  ie\.: i.e.
-  i\.e: i.e.