@gitkraken/core-gitlens 0.7.2 → 0.9.0

package/dist/git-cli/providers/commits.js

@@ -8,8 +8,9 @@ import { fileUri, joinUriPath, toFsPath } from "../../utils/uri.js";
 import { isFolderGlob, normalizePath, splitPath, stripFolderGlob } from "../../utils/path.js";
 import { isRevisionRange, isSha, isUncommitted, isUncommittedStaged } from "../../git/utils/revision.utils.js";
 import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { SigningError } from "../../git/errors.js";
 import { createDisposable } from "../../utils/disposable.js";
-import { GitErrors, gitConfigsLog, gitConfigsLogWithFiles } from "../exec/git.js";
+import { GitErrors, classifySigningError, gitConfigsLog, gitConfigsLogWithFiles } from "../exec/git.js";
 import { GitFileChange } from "../../git/models/fileChange.js";
 import { createUncommittedChangesCommit } from "../../git/utils/commit.utils.js";
 import { GitCommit, GitCommitIdentity } from "../../git/models/commit.js";
@@ -29,6 +30,53 @@ const emptyPromise = Promise.resolve(void 0);
 const reflogCommands = ["merge", "pull"];
 /** Keeps `filterUnpublishedShas` well inside Windows' ~32K command-line cap (40 hex chars + separator each). */
 const maxShasPerRevListSpawn = 500;
+const refExclusionNamespaces = [
+	[
+		"branches",
+		"refs/heads/",
+		"--branches"
+	],
+	[
+		"remotes",
+		"refs/remotes/",
+		"--remotes"
+	],
+	[
+		"tags",
+		"refs/tags/",
+		"--tags"
+	]
+];
+/**
+* Each `except` entry is emitted in its short form right before its own namespace's pseudo-ref: git matches
+* `--exclude` against the short name and applies it only to the next pseudo-ref, so `--exclude=refs/heads/x
+* --branches` excludes nothing.
+*/
+function getRefExclusionArgs(excluding) {
+	if (excluding == null) return [];
+	const args = [];
+	for (const [key, prefix, flag] of refExclusionNamespaces) {
+		if (!excluding[key]) continue;
+		for (const ref of excluding.except ?? []) if (ref.startsWith(prefix)) args.push(`--exclude=${ref.slice(prefix.length)}`);
+		args.push(flag);
+	}
+	if (excluding.refs?.length) args.push(...excluding.refs);
+	return args.length ? ["--not", ...args] : [];
+}
+function getRefExclusionsKey(excluding) {
+	const { branches, remotes, tags, refs, except } = excluding;
+	return JSON.stringify([
+		branches,
+		remotes,
+		tags,
+		refs,
+		except
+	]);
+}
+function getCommitCountKey(rev, excluding) {
+	if (excluding == null) return rev;
+	return `${rev}\0${getRefExclusionsKey(excluding)}`;
+}
 var CommitsGitSubProvider = class {
 	context;
 	git;
@@ -40,12 +88,60 @@ var CommitsGitSubProvider = class {
 		this.cache = cache;
 		this.provider = provider;
 	}
-	async createUnreachableCommitFromTree(repoPath, tree, parent, message, cancellation) {
-		return (await this.git.run({
-			cwd: repoPath,
-			cancellation,
-			errors: "throw"
-		}, "commit-tree", tree, "-p", parent, "-m", message)).stdout.trim();
+	/**
+	* Creates a commit object from a tree via `commit-tree`, with explicit (zero or more) parents and an
+	* optional explicit author/committer — e.g. for merge commits assembled from multiple parents, or a
+	* commit authored on behalf of someone else. Writes the commit object only; it updates no ref, so the
+	* result is unreachable until a caller points a branch/ref at it. Fires no ref-change hooks — an
+	* unreachable object changes no ref, so there's nothing for a cache or watcher to invalidate yet.
+	*/
+	async createCommitFromTree(repoPath, tree, options, cancellation) {
+		const args = ["commit-tree", tree];
+		for (const parent of options.parents) args.push("-p", parent);
+		let format = "gpg";
+		if (options.sign) {
+			format = (await this.provider.config.getSigningConfig?.(repoPath))?.format ?? "gpg";
+			args.push("-S");
+		}
+		args.push("-F", "-");
+		const env = {};
+		if (options.author) {
+			env.GIT_AUTHOR_NAME = options.author.name;
+			env.GIT_AUTHOR_EMAIL = options.author.email;
+			if (options.author.date != null) env.GIT_AUTHOR_DATE = typeof options.author.date === "string" ? options.author.date : options.author.date.toISOString();
+		}
+		if (options.committer) {
+			env.GIT_COMMITTER_NAME = options.committer.name;
+			env.GIT_COMMITTER_EMAIL = options.committer.email;
+			if (options.committer.date != null) env.GIT_COMMITTER_DATE = typeof options.committer.date === "string" ? options.committer.date : options.committer.date.toISOString();
+		}
+		try {
+			const sha = (await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "throw",
+				env,
+				stdin: !options.message || options.message.endsWith("\n") ? options.message : `${options.message}\n`,
+				stdinEncoding: "utf8"
+			}, ...args)).stdout.trim();
+			if (options.sign) this.context.hooks?.commits?.onSigned?.(format, options.source);
+			return sha;
+		} catch (ex) {
+			if (options.sign) {
+				const reason = classifySigningError(ex);
+				if (reason != null) {
+					this.context.hooks?.commits?.onSigningFailed?.(reason, format, options.source);
+					throw new SigningError({
+						reason,
+						gitCommand: {
+							repoPath,
+							args: ["commit-tree"]
+						}
+					}, ex);
+				}
+			}
+			throw ex;
+		}
 	}
 	async getCommit(repoPath, rev, cancellation) {
 		if (isUncommitted(rev, true)) return createUncommittedChangesCommit(repoPath, rev, /* @__PURE__ */ new Date(), await this.provider.config.getCurrentUser(repoPath));
@@ -53,13 +149,14 @@ var CommitsGitSubProvider = class {
 		if (log == null) return void 0;
 		return log.commits.get(rev) ?? first(log.commits.values());
 	}
-	getCommitCount(repoPath, rev, cancellation) {
-		return this.cache.commitCount.getOrCreate(repoPath, rev, async (cacheable, signal) => {
+	getCommitCount(repoPath, rev, options, cancellation) {
+		const excludeArgs = getRefExclusionArgs(options?.excluding);
+		return this.cache.commitCount.getOrCreate(repoPath, getCommitCountKey(rev, options?.excluding), async (cacheable, signal) => {
 			const result = await this.git.run({
 				cwd: repoPath,
 				cancellation: signal ?? cancellation,
 				errors: "ignore"
-			}, "rev-list", "--count", rev, "--");
+			}, "rev-list", "--count", rev, ...excludeArgs, "--");
 			if (result.completion.status === "cancelled" || signal?.aborted) throw new CancellationError();
 			if (result.completion.status !== "exited" || result.exitCode !== 0) {
 				cacheable.invalidate();
@@ -676,7 +773,10 @@ var CommitsGitSubProvider = class {
 					const similarityThreshold = options.similarityThreshold;
 					args.push(`-M${similarityThreshold == null ? "" : `${similarityThreshold}%`}`);
 				}
+				const excludeArgs = getRefExclusionArgs(options.excluding);
 				if (rev && !isUncommittedStaged(rev)) args.push(rev);
+				else if (excludeArgs.length) args.push("HEAD");
+				args.push(...excludeArgs);
 				args.push("--");
 				if (pathspec) args.push(pathspec);
 				const result = await this.git.run({
@@ -692,7 +792,7 @@ var CommitsGitSubProvider = class {
 				return [];
 			}
 		};
-		if (!options.pathOrUri && !options.authors?.length && !options.reverse && !options.all) return this.cache.logShas.getOrCreate(repoPath, `${rev ?? ""}:${options.ordering ?? ""}:${options.limit}:${options.merges}:${options.since ?? ""}`, () => getCore());
+		if (!options.pathOrUri && !options.authors?.length && !options.reverse && !options.all) return this.cache.logShas.getOrCreate(repoPath, `${rev ?? ""}:${options.ordering ?? ""}:${options.limit}:${options.merges}:${options.since ?? ""}${options.excluding == null ? "" : `:${getRefExclusionsKey(options.excluding)}`}`, () => getCore());
 		return getCore();
 	}
 	async getOldestUnpushedShaForPath(repoPath, pathOrUri, cancellation) {
@@ -916,7 +1016,7 @@ var CommitsGitSubProvider = class {
 		return result;
 	}
 };
-__decorate([debug()], CommitsGitSubProvider.prototype, "createUnreachableCommitFromTree", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "createCommitFromTree", null);
 __decorate([debug()], CommitsGitSubProvider.prototype, "getCommit", null);
 __decorate([debug({ exit: true })], CommitsGitSubProvider.prototype, "getCommitCount", null);
 __decorate([debug({ exit: true })], CommitsGitSubProvider.prototype, "hasUnpublishedCommits", null);