protected get shortCommit(): string { return (this.ref.commit || '').substr(0, 8); }

get label(): string { return this.ref.name || this.shortCommit; }

get description(): string { return this.shortCommit; }

constructor(protected ref: Ref) { }

async run(repository: Repository): Promise<void> {

const ref = this.ref.name;

if (!ref) {

return;

}

await repository.checkout(ref);

}

get description(): string {

return localize('tag at', "Tag at {0}", this.shortCommit);

}

get description(): string {

return localize('remote branch at', "Remote branch at {0}", this.shortCommit);

}

async run(repository: Repository): Promise<void> {

if (!this.ref.name) {

return;

}

const branches = await repository.findTrackingBranches(this.ref.name);

if (branches.length > 0) {

await repository.checkout(branches[0].name!);

} else {

await repository.checkoutTracking(this.ref.name);

}

}

private get shortCommit(): string { return (this.ref.commit || '').substr(0, 8); }

get branchName(): string | undefined { return this.ref.name; }

get label(): string { return this.branchName || ''; }

get description(): string { return this.shortCommit; }

constructor(private ref: Ref) { }

async run(repository: Repository, force?: boolean): Promise<void> {

if (!this.branchName) {

return;

}

await repository.deleteBranch(this.branchName, force);

}

get label(): string { return this.ref.name || ''; }

get description(): string { return this.ref.name || ''; }

constructor(protected ref: Ref) { }

async run(repository: Repository): Promise<void> {

await repository.merge(this.ref.name! || this.ref.commit!);

}

constructor(private cc: CommandCenter) { }

get label(): string { return '$(plus) ' + localize('create branch', 'Create new branch...'); }

get description(): string { return ''; }

get alwaysShow(): boolean { return true; }

async run(repository: Repository): Promise<void> {

await this.cc.branch(repository);

}

constructor(private cc: CommandCenter) { }

get label(): string { return '$(plus) ' + localize('create branch from', 'Create new branch from...'); }

get description(): string { return ''; }

get alwaysShow(): boolean { return true; }

async run(repository: Repository): Promise<void> {

await this.cc.branch(repository);

}

constructor(private repository: Repository) { }

get label(): string { return 'HEAD'; }

get description(): string { return (this.repository.HEAD && this.repository.HEAD.commit || '').substr(0, 8); }

get alwaysShow(): boolean { return true; }

constructor(private cc: CommandCenter) { }

get label(): string { return '$(plus) ' + localize('add remote', 'Add a new remote...'); }

get description(): string { return ''; }

get alwaysShow(): boolean { return true; }

async run(repository: Repository): Promise<void> {

await this.cc.addRemote(repository);

}

commandId: string;

key: string;

method: Function;

options: CommandOptions;

return (_target: any, key: string, descriptor: any) => {

if (!(typeof descriptor.value === 'function')) {

throw new Error('not supported');

}

Commands.push({ commandId, key, method: descriptor.value, options });

};

const selection = resources.filter(s => s instanceof Resource) as Resource[];

const merge = selection.filter(s => s.resourceGroupType === ResourceGroupType.Merge);

const isBothAddedOrModified = (s: Resource) => s.type === Status.BOTH_MODIFIED || s.type === Status.BOTH_ADDED;

const isAnyDeleted = (s: Resource) => s.type === Status.DELETED_BY_THEM || s.type === Status.DELETED_BY_US;

const possibleUnresolved = merge.filter(isBothAddedOrModified);

const promises = possibleUnresolved.map(s => grep(s.resourceUri.fsPath, /^<{7}|^={7}|^>{7}/));

const unresolvedBothModified = await Promise.all<boolean>(promises);

const resolved = possibleUnresolved.filter((_s, i) => !unresolvedBothModified[i]);

const deletionConflicts = merge.filter(s => isAnyDeleted(s));

const unresolved = [

...merge.filter(s => !isBothAddedOrModified(s) && !isAnyDeleted(s)),

...possibleUnresolved.filter((_s, i) => unresolvedBothModified[i])

];

return { merge, resolved, unresolved, deletionConflicts };

const config = workspace.getConfiguration('git');

const checkoutType = config.get<string>('checkoutType') || 'all';

const includeTags = checkoutType === 'all' || checkoutType === 'tags';

const includeRemotes = checkoutType === 'all' || checkoutType === 'remote';

const heads = repository.refs.filter(ref => ref.type === RefType.Head)

.map(ref => new CheckoutItem(ref));

const tags = (includeTags ? repository.refs.filter(ref => ref.type === RefType.Tag) : [])

.map(ref => new CheckoutTagItem(ref));

const remoteHeads = (includeRemotes ? repository.refs.filter(ref => ref.type === RefType.RemoteHead) : [])

.map(ref => new CheckoutRemoteHeadItem(ref));

return [...heads, ...tags, ...remoteHeads];

get label(): string { return this.ref.name ?? ''; }

get description(): string { return this.ref.commit?.substr(0, 8) ?? ''; }

constructor(readonly ref: Ref) { }

Push,

PushTo,

PushFollowTags,

pushType: PushType;

forcePush?: boolean;

silent?: boolean;

const result = await new Promise<T | undefined>(c => {

quickpick.onDidAccept(() => c(quickpick.selectedItems[0]));

quickpick.onDidHide(() => c(undefined));

quickpick.show();

});

quickpick.hide();

return result;

private quickpick: QuickPick<QuickPickItem & { remoteSource?: RemoteSource }>;

constructor(private provider: RemoteSourceProvider) {

this.quickpick = window.createQuickPick();

this.quickpick.ignoreFocusOut = true;

if (provider.supportsQuery) {

this.quickpick.placeholder = localize('type to search', "Repository name (type to search)");

this.quickpick.onDidChangeValue(this.onDidChangeValue, this);

} else {

this.quickpick.placeholder = localize('type to filter', "Repository name");

}

}

@debounce(300)

onDidChangeValue(): void {

this.query();

}

@throttle

async query(): Promise<void> {

this.quickpick.busy = true;

try {

const remoteSources = await this.provider.getRemoteSources(this.quickpick.value) || [];

if (remoteSources.length === 0) {

this.quickpick.items = [{

label: localize('none found', "No remote repositories found."),

alwaysShow: true

}];

} else {

this.quickpick.items = remoteSources.map(remoteSource => ({

label: remoteSource.name,

description: remoteSource.description || (typeof remoteSource.url === 'string' ? remoteSource.url : remoteSource.url[0]),

remoteSource

}));

}

} catch (err) {

this.quickpick.items = [{ label: localize('error', "$(error) Error: {0}", err.message), alwaysShow: true }];

console.error(err);

} finally {

this.quickpick.busy = false;

}

}

async pick(): Promise<RemoteSource | undefined> {

this.query();

const result = await getQuickPickResult(this.quickpick);

return result?.remoteSource;

}

private disposables: Disposable[];

constructor(

private git: Git,

private model: Model,

private outputChannel: OutputChannel,

private telemetryReporter: TelemetryReporter

) {

this.disposables = Commands.map(({ commandId, key, method, options }) => {

const command = this.createCommand(commandId, key, method, options);

if (options.diff) {

return commands.registerDiffInformationCommand(commandId, command);

} else {

return commands.registerCommand(commandId, command);

}

});

}

@command('git.setLogLevel')

async setLogLevel(): Promise<void> {

const createItem = (logLevel: LogLevel) => ({

label: LogLevel[logLevel],

logLevel,

description: Log.logLevel === logLevel ? localize('current', "Current") : undefined

});

const items = [

createItem(LogLevel.Trace),

createItem(LogLevel.Debug),

createItem(LogLevel.Info),

createItem(LogLevel.Warning),

createItem(LogLevel.Error),

createItem(LogLevel.Critical),

createItem(LogLevel.Off)

];

const choice = await window.showQuickPick(items, {

placeHolder: localize('select log level', "Select log level")

});

if (!choice) {

return;

}

Log.logLevel = choice.logLevel;

this.outputChannel.appendLine(localize('changed', "Log level changed to: {0}", LogLevel[Log.logLevel]));

}

@command('git.refresh', { repository: true })

async refresh(repository: Repository): Promise<void> {

await repository.status();

}

@command('git.openResource')

async openResource(resource: Resource, preserveFocus: boolean): Promise<void> {

const repository = this.model.getRepository(resource.resourceUri);

if (!repository) {

return;

}

const config = workspace.getConfiguration('git', Uri.file(repository.root));

const openDiffOnClick = config.get<boolean>('openDiffOnClick');

if (openDiffOnClick) {

await this._openResource(resource, undefined, preserveFocus, false);

} else {

await this.openFile(resource);

}

}

private async _openResource(resource: Resource, preview?: boolean, preserveFocus?: boolean, preserveSelection?: boolean): Promise<void> {

let stat: Stats | undefined;

try {

stat = await new Promise<Stats>((c, e) => lstat(resource.resourceUri.fsPath, (err, stat) => err ? e(err) : c(stat)));

} catch (err) {

// noop

}

let left: Uri | undefined;

let right: Uri | undefined;

if (stat && stat.isDirectory()) {

const repository = this.model.getRepositoryForSubmodule(resource.resourceUri);

if (repository) {

right = toGitUri(resource.resourceUri, resource.resourceGroupType === ResourceGroupType.Index ? 'index' : 'wt', { submoduleOf: repository.root });

}

} else {

if (resource.type !== Status.DELETED_BY_THEM) {

left = this.getLeftResource(resource);

}

right = this.getRightResource(resource);

}

const title = this.getTitle(resource);

if (!right) {

// TODO

console.error('oh no');

return;

}

const opts: TextDocumentShowOptions = {

preserveFocus,

preview,

viewColumn: ViewColumn.Active

};

const activeTextEditor = window.activeTextEditor;

// Check if active text editor has same path as other editor. we cannot compare via

// URI.toString() here because the schemas can be different. Instead we just go by path.

if (preserveSelection && activeTextEditor && activeTextEditor.document.uri.path === right.path) {

opts.selection = activeTextEditor.selection;

}

if (!left) {

await commands.executeCommand<void>('vscode.open', right, opts, title);

} else {

await commands.executeCommand<void>('vscode.diff', left, right, title, opts);

}

}

private getLeftResource(resource: Resource): Uri | undefined {

switch (resource.type) {

case Status.INDEX_MODIFIED:

case Status.INDEX_RENAMED:

case Status.INDEX_ADDED:

return toGitUri(resource.original, 'HEAD');

case Status.MODIFIED:

case Status.UNTRACKED:

return toGitUri(resource.resourceUri, '~');

case Status.DELETED_BY_THEM:

return toGitUri(resource.resourceUri, '');

}

return undefined;

}

private getRightResource(resource: Resource): Uri | undefined {

switch (resource.type) {

case Status.INDEX_MODIFIED:

case Status.INDEX_ADDED:

case Status.INDEX_COPIED:

case Status.INDEX_RENAMED:

return toGitUri(resource.resourceUri, '');

case Status.INDEX_DELETED:

case Status.DELETED:

return toGitUri(resource.resourceUri, 'HEAD');

case Status.DELETED_BY_US:

return toGitUri(resource.resourceUri, '~3');

case Status.DELETED_BY_THEM:

return toGitUri(resource.resourceUri, '~2');

case Status.MODIFIED:

case Status.UNTRACKED:

case Status.IGNORED:

case Status.INTENT_TO_ADD:

const repository = this.model.getRepository(resource.resourceUri);

if (!repository) {

return;

}

const uriString = resource.resourceUri.toString();

const [indexStatus] = repository.indexGroup.resourceStates.filter(r => r.resourceUri.toString() === uriString);

if (indexStatus && indexStatus.renameResourceUri) {

return indexStatus.renameResourceUri;

}

return resource.resourceUri;

case Status.BOTH_ADDED:

case Status.BOTH_MODIFIED:

return resource.resourceUri;

}

return undefined;

}

private getTitle(resource: Resource): string {

const basename = path.basename(resource.resourceUri.fsPath);

switch (resource.type) {

case Status.INDEX_MODIFIED:

case Status.INDEX_RENAMED:

case Status.INDEX_ADDED:

return localize('git.title.index', '{0} (Index)', basename);

case Status.MODIFIED:

case Status.BOTH_ADDED:

case Status.BOTH_MODIFIED:

return localize('git.title.workingTree', '{0} (Working Tree)', basename);

case Status.DELETED_BY_US:

return localize('git.title.theirs', '{0} (Theirs)', basename);

case Status.DELETED_BY_THEM:

return localize('git.title.ours', '{0} (Ours)', basename);

case Status.UNTRACKED:

return localize('git.title.untracked', '{0} (Untracked)', basename);

default:

return '';

}

}

@command('git.clone')

async clone(url?: string, parentPath?: string): Promise<void> {

if (!url) {

const quickpick = window.createQuickPick<(QuickPickItem & { provider?: RemoteSourceProvider, url?: string })>();

quickpick.ignoreFocusOut = true;

const providers = this.model.getRemoteProviders()

.map(provider => ({ label: (provider.icon ? `$(${provider.icon}) ` : '') + localize('clonefrom', "Clone from {0}", provider.name), alwaysShow: true, provider }));

quickpick.placeholder = providers.length === 0

? localize('provide url', "Provide repository URL")

: localize('provide url or pick', "Provide repository URL or pick a repository source.");

const updatePicks = (value?: string) => {

if (value) {

quickpick.items = [{

label: localize('repourl', "Clone from URL"),

description: value,

alwaysShow: true,

url: value

},

...providers];

} else {

quickpick.items = providers;

}

};

quickpick.onDidChangeValue(updatePicks);

updatePicks();

const result = await getQuickPickResult(quickpick);

if (result) {

if (result.url) {

url = result.url;

} else if (result.provider) {

const quickpick = new RemoteSourceProviderQuickPick(result.provider);

const remote = await quickpick.pick();

if (remote) {

if (typeof remote.url === 'string') {

url = remote.url;

} else if (remote.url.length > 0) {

url = await window.showQuickPick(remote.url, { ignoreFocusOut: true, placeHolder: localize('pick url', "Choose a URL to clone from.") });

}

}

}

}

}

if (!url) {

/* __GDPR__

this.telemetryReporter.sendTelemetryEvent('clone', { outcome: 'no_URL' });

return;

}

url = url.trim().replace(/^git\s+clone\s+/, '');

if (!parentPath) {

const config = workspace.getConfiguration('git');

let defaultCloneDirectory = config.get<string>('defaultCloneDirectory') || os.homedir();

defaultCloneDirectory = defaultCloneDirectory.replace(/^~/, os.homedir());

const uris = await window.showOpenDialog({

canSelectFiles: false,

canSelectFolders: true,

canSelectMany: false,

defaultUri: Uri.file(defaultCloneDirectory),

openLabel: localize('selectFolder', "Select Repository Location")

});

if (!uris || uris.length === 0) {

/* __GDPR__

this.telemetryReporter.sendTelemetryEvent('clone', { outcome: 'no_directory' });

return;

}

const uri = uris[0];

parentPath = uri.fsPath;

}

try {

const opts = {

location: ProgressLocation.Notification,

title: localize('cloning', "Cloning git repository '{0}'...", url),

cancellable: true

};

const repositoryPath = await window.withProgress(

opts,

(progress, token) => this.git.clone(url!, parentPath!, progress, token)

);

let message = localize('proposeopen', "Would you like to open the cloned repository?");

const open = localize('openrepo', "Open");

const openNewWindow = localize('openreponew', "Open in New Window");

const choices = [open, openNewWindow];

const addToWorkspace = localize('add', "Add to Workspace");

if (workspace.workspaceFolders) {

message = localize('proposeopen2', "Would you like to open the cloned repository, or add it to the current workspace?");

choices.push(addToWorkspace);

}

const result = await window.showInformationMessage(message, ...choices);

const openFolder = result === open;

/* __GDPR__

this.telemetryReporter.sendTelemetryEvent('clone', { outcome: 'success' }, { openFolder: openFolder ? 1 : 0 });

const uri = Uri.file(repositoryPath);

if (openFolder) {

commands.executeCommand('vscode.openFolder', uri);

} else if (result === addToWorkspace) {

workspace.updateWorkspaceFolders(workspace.workspaceFolders!.length, 0, { uri });

} else if (result === openNewWindow) {

commands.executeCommand('vscode.openFolder', uri, true);

}

} catch (err) {

if (/already exists and is not an empty directory/.test(err && err.stderr || '')) {

/* __GDPR__

this.telemetryReporter.sendTelemetryEvent('clone', { outcome: 'directory_not_empty' });

} else if (/Cancelled/i.test(err && (err.message || err.stderr || ''))) {

return;

} else {

/* __GDPR__

this.telemetryReporter.sendTelemetryEvent('clone', { outcome: 'error' });

}

throw err;

}

}

@command('git.init')

async init(skipFolderPrompt = false): Promise<void> {

let repositoryPath: string | undefined = undefined;

let askToOpen = true;

if (workspace.workspaceFolders) {

if (skipFolderPrompt && workspace.workspaceFolders.length === 1) {

repositoryPath = workspace.workspaceFolders[0].uri.fsPath;

askToOpen = false;

} else {

const placeHolder = localize('init', "Pick workspace folder to initialize git repo in");

const pick = { label: localize('choose', "Choose Folder...") };

const items: { label: string, folder?: WorkspaceFolder }[] = [

...workspace.workspaceFolders.map(folder => ({ label: folder.name, description: folder.uri.fsPath, folder })),

pick

];

const item = await window.showQuickPick(items, { placeHolder, ignoreFocusOut: true });

if (!item) {

return;

} else if (item.folder) {

repositoryPath = item.folder.uri.fsPath;

askToOpen = false;

}

}

}

if (!repositoryPath) {

const homeUri = Uri.file(os.homedir());

const defaultUri = workspace.workspaceFolders && workspace.workspaceFolders.length > 0

? Uri.file(workspace.workspaceFolders[0].uri.fsPath)

: homeUri;

const result = await window.showOpenDialog({

canSelectFiles: false,

canSelectFolders: true,

canSelectMany: false,

defaultUri,

openLabel: localize('init repo', "Initialize Repository")

});

if (!result || result.length === 0) {

return;

}

const uri = result[0];

if (homeUri.toString().startsWith(uri.toString())) {

const yes = localize('create repo', "Initialize Repository");

const answer = await window.showWarningMessage(localize('are you sure', "This will create a Git repository in '{0}'. Are you sure you want to continue?", uri.fsPath), yes);