/*---------------------------------------------------------------------------------------------

* Copyright (c) Microsoft Corporation. All rights reserved.

* Licensed under the MIT License. See License.txt in the project root for license information.

*--------------------------------------------------------------------------------------------*/

import { lstat, Stats } from 'fs';

import * as os from 'os';

import * as path from 'path';

import { commands, Disposable, LineChange, MessageOptions, OutputChannel, Position, ProgressLocation, QuickPickItem, Range, SourceControlResourceState, TextDocumentShowOptions, TextEditor, Uri, ViewColumn, window, workspace, WorkspaceEdit, WorkspaceFolder, TimelineItem, env, Selection } from 'vscode';

import TelemetryReporter from 'vscode-extension-telemetry';

import * as nls from 'vscode-nls';

import { Branch, GitErrorCodes, Ref, RefType, Status, CommitOptions, RemoteSourceProvider } from './api/git';

import { ForcePushMode, Git, Stash } from './git';

import { Model } from './model';

import { Repository, Resource, ResourceGroupType } from './repository';

import { applyLineChanges, getModifiedRange, intersectDiffWithRange, invertLineChange, toLineRanges } from './staging';

import { fromGitUri, toGitUri, isGitUri } from './uri';

import { grep, isDescendant, pathEquals } from './util';

import { Log, LogLevel } from './log';

import { GitTimelineItem } from './timelineProvider';

import { ApiRepository } from './api/api1';

import { pickRemoteSource } from './remoteSource';

const localize = nls.loadMessageBundle();

class CheckoutItem implements QuickPickItem {

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);

}

}

class CheckoutTagItem extends CheckoutItem {

get description(): string {

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

}

}

class CheckoutRemoteHeadItem extends CheckoutItem {

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);

}

}

}

class BranchDeleteItem implements QuickPickItem {

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);

}

}

class MergeItem implements QuickPickItem {

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!);

}

}

class CreateBranchItem implements QuickPickItem {

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);

}

}

class CreateBranchFromItem implements QuickPickItem {

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);

}

}

class HEADItem implements QuickPickItem {

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; }

}

class AddRemoteItem implements QuickPickItem {

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);

}

}

interface CommandOptions {

repository?: boolean;

diff?: boolean;

}

interface Command {

commandId: string;

key: string;

method: Function;

options: CommandOptions;

}

const Commands: Command[] = [];

function command(commandId: string, options: CommandOptions = {}): Function {

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 ImageMimetypes = [

// 'image/png',

// 'image/gif',

// 'image/jpeg',

// 'image/webp',

// 'image/tiff',

// 'image/bmp'

// ];

async function categorizeResourceByResolution(resources: Resource[]): Promise<{ merge: Resource[], resolved: Resource[], unresolved: Resource[], deletionConflicts: Resource[] }> {

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 };

}

function createCheckoutItems(repository: Repository): CheckoutItem[] {

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];

}

function sanitizeRemoteName(name: string) {

name = name.trim();

return name && name.replace(/^\.|\/\.|\.\.|~|\^|:|\/$|\.lock$|\.lock\/|\\|\*|\s|^\s*$|\.$|\[|\]$/g, '-');

}

class TagItem implements QuickPickItem {

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

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

constructor(readonly ref: Ref) { }

}

enum PushType {

Push,

PushTo,

PushFollowTags,

}

interface PushOptions {

pushType: PushType;

forcePush?: boolean;

silent?: boolean;

}

export class CommandCenter {

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 || typeof url !== 'string') {

url = await pickRemoteSource(this.model, {

providerLabel: provider => localize('clonefrom', "Clone from {0}", provider.name),

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

});

}

if (!url) {

/* __GDPR__

"clone" : {

"outcome" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }

}

*/

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__

"clone" : {

"outcome" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }

}

*/

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__

"clone" : {

"outcome" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"openFolder": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true }

}

*/

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

const uri = Uri.file(repositoryPath);

if (openFolder) {

commands.executeCommand('vscode.openFolder', uri, { forceReuseWindow: true });

} else if (result === addToWorkspace) {

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

} else if (result === openNewWindow) {

commands.executeCommand('vscode.openFolder', uri, { forceNewWindow: true });

}

} catch (err) {

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

/* __GDPR__

"clone" : {

"outcome" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }

}

*/

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

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

return;

} else {

/* __GDPR__

"clone" : {

"outcome" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }

}

*/

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);

if (answer !== yes) {

return;

}

}

repositoryPath = uri.fsPath;

if (workspace.workspaceFolders && workspace.workspaceFolders.some(w => w.uri.toString() === uri.toString())) {

askToOpen = false;

}

}

await this.git.init(repositoryPath);

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

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

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

const choices = [open, openNewWindow];

if (!askToOpen) {

return;

}

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

if (workspace.workspaceFolders) {

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

choices.push(addToWorkspace);

}

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

const uri = Uri.file(repositoryPath);

if (result === open) {

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);

} else {

await this.model.openRepository(repositoryPath);

}

}

@command('git.openRepository', { repository: false })

async openRepository(path?: string): Promise<void> {

if (!path) {

const result = await window.showOpenDialog({

canSelectFiles: false,

canSelectFolders: true,

canSelectMany: false,

defaultUri: Uri.file(os.homedir()),

openLabel: localize('open repo', "Open Repository")

});

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

return;

}

path = result[0].fsPath;

}

await this.model.openRepository(path);

}

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

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

this.model.close(repository);

}

@command('git.openFile')

async openFile(arg?: Resource | Uri, ...resourceStates: SourceControlResourceState[]): Promise<void> {

const preserveFocus = arg instanceof Resource;

let uris: Uri[] | undefined;

if (arg instanceof Uri) {

if (isGitUri(arg)) {

uris = [Uri.file(fromGitUri(arg).path)];

} else if (arg.scheme === 'file') {

uris = [arg];

}

} else {

let resource = arg;

if (!(resource instanceof Resource)) {

// can happen when called from a keybinding

resource = this.getSCMResource();

}

if (resource) {

uris = ([resource, ...resourceStates] as Resource[])

.filter(r => r.type !== Status.DELETED && r.type !== Status.INDEX_DELETED)

.map(r => r.resourceUri);

} else if (window.activeTextEditor) {

uris = [window.activeTextEditor.document.uri];

}

}

if (!uris) {

return;

}

const activeTextEditor = window.activeTextEditor;

for (const uri of uris) {

const opts: TextDocumentShowOptions = {

preserveFocus,

preview: false,

viewColumn: ViewColumn.Active

};

let document;

try {

document = await workspace.openTextDocument(uri);

} catch (error) {

await commands.executeCommand('vscode.open', uri, opts);

continue;

}

// 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 (activeTextEditor && activeTextEditor.document.uri.path === uri.path) {

// preserve not only selection but also visible range

opts.selection = activeTextEditor.selection;

const previousVisibleRanges = activeTextEditor.visibleRanges;

const editor = await window.showTextDocument(document, opts);

editor.revealRange(previousVisibleRanges[0]);

} else {

await commands.executeCommand('vscode.open', uri, opts);

}

}

}

@command('git.openFile2')

async openFile2(arg?: Resource | Uri, ...resourceStates: SourceControlResourceState[]): Promise<void> {

this.openFile(arg, ...resourceStates);

}

@command('git.openHEADFile')

async openHEADFile(arg?: Resource | Uri): Promise<void> {

let resource: Resource | undefined = undefined;

const preview = !(arg instanceof Resource);

if (arg instanceof Resource) {

resource = arg;

} else if (arg instanceof Uri) {

resource = this.getSCMResource(arg);

} else {

resource = this.getSCMResource();

}

if (!resource) {

return;

}

const HEAD = this.getLeftResource(resource);

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

const title = `${basename} (HEAD)`;

if (!HEAD) {

window.showWarningMessage(localize('HEAD not available', "HEAD version of '{0}' is not available.", path.basename(resource.resourceUri.fsPath)));

return;

}

const opts: TextDocumentShowOptions = {

preview

};

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

}

@command('git.openChange')

async openChange(arg?: Resource | Uri, ...resourceStates: SourceControlResourceState[]): Promise<void> {

const preserveFocus = arg instanceof Resource;

const preview = !(arg instanceof Resource);

const preserveSelection = arg instanceof Uri || !arg;

let resources: Resource[] | undefined = undefined;

if (arg instanceof Uri) {

const resource = this.getSCMResource(arg);

if (resource !== undefined) {

resources = [resource];

}

} else {

let resource: Resource | undefined = undefined;

if (arg instanceof Resource) {

resource = arg;

} else {

resource = this.getSCMResource();

}

if (resource) {

resources = [...resourceStates as Resource[], resource];

}

}

if (!resources) {

return;

}

for (const resource of resources) {

await this._openResource(resource, preview, preserveFocus, preserveSelection);

}

}

@command('git.stage')

async stage(...resourceStates: SourceControlResourceState[]): Promise<void> {

this.outputChannel.appendLine(`git.stage ${resourceStates.length}`);

resourceStates = resourceStates.filter(s => !!s);

if (resourceStates.length === 0 || (resourceStates[0] && !(resourceStates[0].resourceUri instanceof Uri))) {

const resource = this.getSCMResource();

this.outputChannel.appendLine(`git.stage.getSCMResource ${resource ? resource.resourceUri.toString() : null}`);

if (!resource) {

return;

}

resourceStates = [resource];

}

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

const { resolved, unresolved, deletionConflicts } = await categorizeResourceByResolution(selection);

if (unresolved.length > 0) {

const message = unresolved.length > 1

? localize('confirm stage files with merge conflicts', "Are you sure you want to stage {0} files with merge conflicts?", unresolved.length)

: localize('confirm stage file with merge conflicts', "Are you sure you want to stage {0} with merge conflicts?", path.basename(unresolved[0].resourceUri.fsPath));

const yes = localize('yes', "Yes");

const pick = await window.showWarningMessage(message, { modal: true }, yes);

if (pick !== yes) {

return;

}

}

try {

await this.runByRepository(deletionConflicts.map(r => r.resourceUri), async (repository, resources) => {

for (const resource of resources) {

await this._stageDeletionConflict(repository, resource);

}

});

} catch (err) {

if (/Cancelled/.test(err.message)) {

return;

}

throw err;

}

const workingTree = selection.filter(s => s.resourceGroupType === ResourceGroupType.WorkingTree);

const untracked = selection.filter(s => s.resourceGroupType === ResourceGroupType.Untracked);

const scmResources = [...workingTree, ...untracked, ...resolved, ...unresolved];

this.outputChannel.appendLine(`git.stage.scmResources ${scmResources.length}`);

if (!scmResources.length) {

return;

}

const resources = scmResources.map(r => r.resourceUri);

await this.runByRepository(resources, async (repository, resources) => repository.add(resources));

}

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

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

const resources = [...repository.workingTreeGroup.resourceStates, ...repository.untrackedGroup.resourceStates];

const uris = resources.map(r => r.resourceUri);

if (uris.length > 0) {

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

const untrackedChanges = config.get<'mixed' | 'separate' | 'hidden'>('untrackedChanges');

await repository.add(uris, untrackedChanges === 'mixed' ? undefined : { update: true });

}

}

private async _stageDeletionConflict(repository: Repository, uri: Uri): Promise<void> {

const uriString = uri.toString();

const resource = repository.mergeGroup.resourceStates.filter(r => r.resourceUri.toString() === uriString)[0];

if (!resource) {

return;

}

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

const keepIt = localize('keep ours', "Keep Our Version");

const deleteIt = localize('delete', "Delete File");

const result = await window.showInformationMessage(localize('deleted by them', "File '{0}' was deleted by them and modified by us.\n\nWhat would you like to do?", path.basename(uri.fsPath)), { modal: true }, keepIt, deleteIt);

if (result === keepIt) {

await repository.add([uri]);

} else if (result === deleteIt) {

await repository.rm([uri]);

} else {

throw new Error('Cancelled');

}

} else if (resource.type === Status.DELETED_BY_US) {

const keepIt = localize('keep theirs', "Keep Their Version");

const deleteIt = localize('delete', "Delete File");

const result = await window.showInformationMessage(localize('deleted by us', "File '{0}' was deleted by us and modified by them.\n\nWhat would you like to do?", path.basename(uri.fsPath)), { modal: true }, keepIt, deleteIt);

if (result === keepIt) {

await repository.add([uri]);

} else if (result === deleteIt) {

await repository.rm([uri]);

} else {

throw new Error('Cancelled');

}

}

}

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

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

const resources = repository.workingTreeGroup.resourceStates

.filter(r => r.type !== Status.UNTRACKED && r.type !== Status.IGNORED);

const uris = resources.map(r => r.resourceUri);

await repository.add(uris);

}

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

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

const resources = [...repository.workingTreeGroup.resourceStates, ...repository.untrackedGroup.resourceStates]

.filter(r => r.type === Status.UNTRACKED || r.type === Status.IGNORED);

const uris = resources.map(r => r.resourceUri);

await repository.add(uris);

}

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

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

const resources = repository.mergeGroup.resourceStates.filter(s => s instanceof Resource) as Resource[];

const { merge, unresolved, deletionConflicts } = await categorizeResourceByResolution(resources);

try {

for (const deletionConflict of deletionConflicts) {

await this._stageDeletionConflict(repository, deletionConflict.resourceUri);

}

} catch (err) {

if (/Cancelled/.test(err.message)) {

return;

}

throw err;

}

if (unresolved.length > 0) {

const message = unresolved.length > 1

? localize('confirm stage files with merge conflicts', "Are you sure you want to stage {0} files with merge conflicts?", merge.length)

: localize('confirm stage file with merge conflicts', "Are you sure you want to stage {0} with merge conflicts?", path.basename(merge[0].resourceUri.fsPath));

const yes = localize('yes', "Yes");

const pick = await window.showWarningMessage(message, { modal: true }, yes);

if (pick !== yes) {

return;

}

}

const uris = resources.map(r => r.resourceUri);

if (uris.length > 0) {

await repository.add(uris);

}

}

@command('git.stageChange')

async stageChange(uri: Uri, changes: LineChange[], index: number): Promise<void> {

const textEditor = window.visibleTextEditors.filter(e => e.document.uri.toString() === uri.toString())[0];

if (!textEditor) {