Extracts getPseudoCommits into reusable helper

Author: eamodio

src/git/models/statusFile.ts

@@ -2,15 +2,15 @@
 import type { Uri } from 'vscode';
 import type { Container } from '../../container';
 import { memoize } from '../../system/decorators/-webview/memoize';
-import { createUncommittedChangesCommit } from '../utils/-webview/commit.utils';
 import { getGitFileFormattedDirectory, getGitFileFormattedPath } from '../utils/-webview/file.utils';
+import { getPseudoCommits } from '../utils/-webview/statusFile.utils';
 import { getGitFileStatusText } from '../utils/fileStatus.utils';
 import type { GitCommit } from './commit';
 import type { GitFile } from './file';
 import { GitFileChange } from './fileChange';
 import type { GitFileStatus } from './fileStatus';
 import { GitFileConflictStatus, GitFileIndexStatus, GitFileWorkingTreeStatus } from './fileStatus';
-import { uncommitted, uncommittedStaged } from './revision';
+import { uncommittedStaged } from './revision';
 import type { GitUser } from './user';
 
 export class GitStatusFile implements GitFile {
@@ -127,73 +127,7 @@ export class GitStatusFile implements GitFile {
 	}
 
 	getPseudoCommits(container: Container, user: GitUser | undefined): GitCommit[] {
-		let now = new Date();
-
-		if (this.conflicted) {
-			const file = new GitFileChange(
-				container,
-				this.repoPath,
-				this.path,
-				this.status,
-				this.originalPath,
-				'HEAD',
-				undefined,
-				false,
-			);
-			return [
-				createUncommittedChangesCommit(container, this.repoPath, uncommitted, now, user, {
-					files: { file: file, files: [file] },
-					parents: ['HEAD'],
-				}),
-			];
-		}
-
-		const commits: GitCommit[] = [];
-		const staged = this.staged;
-
-		if (this.wip) {
-			const previousSha = staged ? uncommittedStaged : 'HEAD';
-			const file = new GitFileChange(
-				this.container,
-				this.repoPath,
-				this.path,
-				this.workingTreeStatus ?? this.status,
-				this.originalPath,
-				previousSha,
-				undefined,
-				false,
-			);
-			commits.push(
-				createUncommittedChangesCommit(container, this.repoPath, uncommitted, now, user, {
-					files: { file: file, files: [file] },
-					parents: [previousSha],
-				}),
-			);
-
-			// Decrements the date to guarantee the staged entry (if exists) will be sorted after the working entry (most recent first)
-			now = new Date(now.getTime() - 60000);
-		}
-
-		if (staged) {
-			const file = new GitFileChange(
-				this.container,
-				this.repoPath,
-				this.path,
-				this.indexStatus ?? this.status,
-				this.originalPath,
-				'HEAD',
-				undefined,
-				true,
-			);
-			commits.push(
-				createUncommittedChangesCommit(container, this.repoPath, uncommittedStaged, now, user, {
-					files: { file: file, files: [file] },
-					parents: ['HEAD'],
-				}),
-			);
-		}
-
-		return commits;
+		return getPseudoCommits(container, [this], user);
 	}
 
 	getPseudoFileChanges(): GitFileChange[] {

src/git/utils/-webview/statusFile.utils.ts

@@ -0,0 +1,126 @@
+import type { Container } from '../../../container';
+import type { GitCommit } from '../../models/commit';
+import { GitFileChange } from '../../models/fileChange';
+import { uncommitted, uncommittedStaged } from '../../models/revision';
+import type { GitStatusFile } from '../../models/statusFile';
+import type { GitUser } from '../../models/user';
+import { createUncommittedChangesCommit } from './commit.utils';
+
+export function getPseudoCommits(
+	container: Container,
+	files: GitStatusFile[] | undefined,
+	user: GitUser | undefined,
+): GitCommit[] {
+	if (!files?.length) return [];
+
+	let now = new Date();
+	const repoPath = files[0].repoPath;
+
+	let conflicted: GitFileChange[] | undefined;
+	let staged: GitFileChange[] | undefined;
+	let wip: GitFileChange[] | undefined;
+
+	for (const file of files) {
+		if (file.conflicted) {
+			conflicted ??= [];
+			conflicted.push(
+				new GitFileChange(
+					container,
+					repoPath,
+					file.path,
+					file.status,
+					file.originalPath,
+					'HEAD',
+					undefined,
+					false,
+				),
+			);
+		} else {
+			if (file.wip) {
+				wip ??= [];
+				wip.push(
+					new GitFileChange(
+						container,
+						repoPath,
+						file.path,
+						file.workingTreeStatus ?? file.status,
+						file.originalPath,
+						file.staged ? uncommittedStaged : 'HEAD',
+						undefined,
+						false,
+					),
+				);
+			}
+
+			if (file.staged) {
+				staged ??= [];
+				staged.push(
+					new GitFileChange(
+						container,
+						repoPath,
+						file.path,
+						file.indexStatus ?? file.status,
+						file.originalPath,
+						'HEAD',
+						undefined,
+						true,
+					),
+				);
+			}
+		}
+	}
+
+	const commits: GitCommit[] = [];
+
+	if (conflicted?.length || wip?.length) {
+		const conflictedAndWipFiles = [...(conflicted ?? []), ...(wip ?? [])];
+		commits.push(
+			createUncommittedChangesCommit(container, repoPath, uncommitted, now, user, {
+				files: {
+					file: conflictedAndWipFiles.length === 1 ? conflictedAndWipFiles[0] : undefined,
+					files: conflictedAndWipFiles,
+				},
+				parents: [staged?.length ? uncommittedStaged : 'HEAD'],
+			}),
+		);
+
+		// Decrements the date to guarantee the staged entry (if exists) will be sorted before the working entry (most recent first)
+		now = new Date(now.getTime() - 60000);
+	}
+
+	if (staged?.length) {
+		commits.push(
+			createUncommittedChangesCommit(container, repoPath, uncommittedStaged, now, user, {
+				files: { file: staged.length === 1 ? staged[0] : undefined, files: staged },
+				parents: ['HEAD'],
+			}),
+		);
+	}
+
+	return commits;
+}
+
+export async function getPseudoCommitsWithStats(
+	container: Container,
+	files: GitStatusFile[] | undefined,
+	user: GitUser | undefined,
+): Promise<GitCommit[]> {
+	const pseudoCommits = getPseudoCommits(container, files, user);
+	if (!pseudoCommits.length) return pseudoCommits;
+
+	const diffProvider = container.git.diff(pseudoCommits[0].repoPath);
+
+	const commits: GitCommit[] = [];
+
+	for (const commit of pseudoCommits) {
+		commits.push(
+			commit.with({
+				stats: await diffProvider.getChangedFilesCount(commit.sha, 'HEAD', {
+					uris: commit.files?.map(f => f.uri),
+				}),
+			}),
+		);
+	}
+
+	return commits;
+}