x: string;

y: string;

path: string;

rename?: string;

fetchUrl?: string;

pushUrl?: string;

isReadOnly: boolean;

/** Optional. The maximum number of log entries to retrieve. */

readonly maxEntries?: number | string;

/** Optional. The Git sha (hash) to start retrieving log entries from. */

readonly hash?: string;

/** Optional. Specifies whether to start retrieving log entries in reverse order. */

readonly reverse?: boolean;

readonly sortByAuthorDate?: boolean;

return new Promise<IGit>((c, e) => {

onLookup(path);

const buffers: Buffer[] = [];

const child = cp.spawn(path, ['--version']);

child.stdout.on('data', (b: Buffer) => buffers.push(b));

child.on('error', cpErrorHandler(e));

child.on('exit', code => code ? e(new Error('Not found')) : c({ path, version: parseVersion(Buffer.concat(buffers).toString('utf8').trim()) }));

});

return new Promise<IGit>((c, e) => {

cp.exec('which git', (err, gitPathBuffer) => {

if (err) {

return e('git not found');

}

const path = gitPathBuffer.toString().replace(/^\s+|\s+$/g, '');

function getVersion(path: string) {

onLookup(path);

// make sure git executes

cp.exec('git --version', (err, stdout) => {

if (err) {

return e('git not found');

}

return c({ path, version: parseVersion(stdout.trim()) });

});

}

if (path !== '/usr/bin/git') {

return getVersion(path);

}

// must check if XCode is installed

cp.exec('xcode-select -p', (err: any) => {

if (err && err.code === 2) {

// git is not installed, and launching /usr/bin/git

// will prompt the user to install it

return e('git not found');

}

getVersion(path);

});

});

});

if (!base) {

return Promise.reject<IGit>('Not found');

}

return findSpecificGit(path.join(base, 'Git', 'cmd', 'git.exe'), onLookup);

return findSystemGitWin32(process.env['ProgramW6432'] as string, onLookup)

.then(undefined, () => findSystemGitWin32(process.env['ProgramFiles(x86)'] as string, onLookup))

.then(undefined, () => findSystemGitWin32(process.env['ProgramFiles'] as string, onLookup))

.then(undefined, () => findSystemGitWin32(path.join(process.env['LocalAppData'] as string, 'Programs'), onLookup))

.then(undefined, () => findGitWin32InPath(onLookup));

const first = hint ? findSpecificGit(hint, onLookup) : Promise.reject<IGit>(null);

return first

.then(undefined, () => {

switch (process.platform) {

case 'darwin': return findGitDarwin(onLookup);

case 'win32': return findGitWin32(onLookup);

default: return findSpecificGit('git', onLookup);

}

})

.then(null, () => Promise.reject(new Error('Git installation not found.')));

exitCode: number;

stdout: T;

stderr: string;

return err => {

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

err = new GitError({

error: err,

message: 'Failed to execute git (ENOENT)',

gitErrorCode: GitErrorCodes.NotAGitRepository

});

}

cb(err);

};

input?: string;

encoding?: string;

log?: boolean;

cancellationToken?: CancellationToken;

onSpawn?: (childProcess: cp.ChildProcess) => void;

if (!child.stdout || !child.stderr) {

throw new GitError({ message: 'Failed to get stdout or stderr from git process.' });

}

if (cancellationToken && cancellationToken.isCancellationRequested) {

throw new GitError({ message: 'Cancelled' });

}

const disposables: IDisposable[] = [];

const once = (ee: NodeJS.EventEmitter, name: string, fn: (...args: any[]) => void) => {

ee.once(name, fn);

disposables.push(toDisposable(() => ee.removeListener(name, fn)));

};

const on = (ee: NodeJS.EventEmitter, name: string, fn: (...args: any[]) => void) => {

ee.on(name, fn);

disposables.push(toDisposable(() => ee.removeListener(name, fn)));

};

let result = Promise.all<any>([

new Promise<number>((c, e) => {

once(child, 'error', cpErrorHandler(e));

once(child, 'exit', c);

}),

new Promise<Buffer>(c => {

const buffers: Buffer[] = [];

on(child.stdout!, 'data', (b: Buffer) => buffers.push(b));

once(child.stdout!, 'close', () => c(Buffer.concat(buffers)));

}),

new Promise<string>(c => {

const buffers: Buffer[] = [];

on(child.stderr!, 'data', (b: Buffer) => buffers.push(b));

once(child.stderr!, 'close', () => c(Buffer.concat(buffers).toString('utf8')));

})

]) as Promise<[number, Buffer, string]>;

if (cancellationToken) {

const cancellationPromise = new Promise<[number, Buffer, string]>((_, e) => {

onceEvent(cancellationToken.onCancellationRequested)(() => {

try {

child.kill();

} catch (err) {

// noop

}

e(new GitError({ message: 'Cancelled' }));

});

});

result = Promise.race([result, cancellationPromise]);

}

try {

const [exitCode, stdout, stderr] = await result;

return { exitCode, stdout, stderr };

} finally {

dispose(disposables);

}

error?: Error;

message?: string;

stdout?: string;

stderr?: string;

exitCode?: number;

gitErrorCode?: string;

gitCommand?: string;

error?: Error;

message: string;

stdout?: string;

stderr?: string;

exitCode?: number;

gitErrorCode?: string;

gitCommand?: string;

constructor(data: IGitErrorData) {

if (data.error) {

this.error = data.error;

this.message = data.error.message;

} else {

this.error = undefined;

this.message = '';

}

this.message = this.message || data.message || 'Git error';

this.stdout = data.stdout;

this.stderr = data.stderr;

this.exitCode = data.exitCode;

this.gitErrorCode = data.gitErrorCode;

this.gitCommand = data.gitCommand;

}

toString(): string {

let result = this.message + ' ' + JSON.stringify({

exitCode: this.exitCode,

gitErrorCode: this.gitErrorCode,

gitCommand: this.gitCommand,

stdout: this.stdout,

stderr: this.stderr

}, null, 2);

if (this.error) {

result += (<any>this.error).stack;

}

return result;

}

gitPath: string;

version: string;

env?: any;

if (/Another git process seems to be running in this repository|If no other git process is currently running/.test(stderr)) {

return GitErrorCodes.RepositoryIsLocked;

} else if (/Authentication failed/i.test(stderr)) {

return GitErrorCodes.AuthenticationFailed;

} else if (/Not a git repository/i.test(stderr)) {

return GitErrorCodes.NotAGitRepository;

} else if (/bad config file/.test(stderr)) {

return GitErrorCodes.BadConfigFile;

} else if (/cannot make pipe for command substitution|cannot create standard input pipe/.test(stderr)) {

return GitErrorCodes.CantCreatePipe;

} else if (/Repository not found/.test(stderr)) {

return GitErrorCodes.RepositoryNotFound;

} else if (/unable to access/.test(stderr)) {

return GitErrorCodes.CantAccessRemote;

} else if (/branch '.+' is not fully merged/.test(stderr)) {

return GitErrorCodes.BranchNotFullyMerged;

} else if (/Couldn\'t find remote ref/.test(stderr)) {

return GitErrorCodes.NoRemoteReference;

} else if (/A branch named '.+' already exists/.test(stderr)) {

return GitErrorCodes.BranchAlreadyExists;

} else if (/'.+' is not a valid branch name/.test(stderr)) {

return GitErrorCodes.InvalidBranchName;

} else if (/Please,? commit your changes or stash them/.test(stderr)) {

return GitErrorCodes.DirtyWorkTree;

}

return undefined;

readonly path: string;

private env: any;

private _onOutput = new EventEmitter();

get onOutput(): EventEmitter { return this._onOutput; }

constructor(options: IGitOptions) {

this.path = options.gitPath;

this.env = options.env || {};

}

open(repository: string, dotGit: string): Repository {

return new Repository(this, repository, dotGit);

}

async init(repository: string): Promise<void> {

await this.exec(repository, ['init']);

return;

}

async clone(url: string, parentPath: string, progress: Progress<{ increment: number }>, cancellationToken?: CancellationToken): Promise<string> {

let baseFolderName = decodeURI(url).replace(/[\/]+$/, '').replace(/^.*[\/\\]/, '').replace(/\.git$/, '') || 'repository';

let folderName = baseFolderName;

let folderPath = path.join(parentPath, folderName);

let count = 1;

while (count < 20 && await new Promise(c => exists(folderPath, c))) {

folderName = `${baseFolderName}-${count++}`;

folderPath = path.join(parentPath, folderName);

}

await mkdirp(parentPath);

const onSpawn = (child: cp.ChildProcess) => {

const decoder = new StringDecoder('utf8');

const lineStream = new byline.LineStream({ encoding: 'utf8' });

child.stderr!.on('data', (buffer: Buffer) => lineStream.write(decoder.write(buffer)));

let totalProgress = 0;

let previousProgress = 0;

lineStream.on('data', (line: string) => {

let match: RegExpMatchArray | null = null;

if (match = /Counting objects:\s*(\d+)%/i.exec(line)) {

totalProgress = Math.floor(parseInt(match[1]) * 0.1);

} else if (match = /Compressing objects:\s*(\d+)%/i.exec(line)) {

totalProgress = 10 + Math.floor(parseInt(match[1]) * 0.1);

} else if (match = /Receiving objects:\s*(\d+)%/i.exec(line)) {

totalProgress = 20 + Math.floor(parseInt(match[1]) * 0.4);

} else if (match = /Resolving deltas:\s*(\d+)%/i.exec(line)) {

totalProgress = 60 + Math.floor(parseInt(match[1]) * 0.4);

}

if (totalProgress !== previousProgress) {

progress.report({ increment: totalProgress - previousProgress });

previousProgress = totalProgress;

}

});

};

try {

await this.exec(parentPath, ['clone', url.includes(' ') ? encodeURI(url) : url, folderPath, '--progress'], { cancellationToken, onSpawn });

} catch (err) {

if (err.stderr) {

err.stderr = err.stderr.replace(/^Cloning.+$/m, '').trim();

err.stderr = err.stderr.replace(/^ERROR:\s+/, '').trim();

}

throw err;

}

return folderPath;

}

async getRepositoryRoot(repositoryPath: string): Promise<string> {

const result = await this.exec(repositoryPath, ['rev-parse', '--show-toplevel']);

// Keep trailing spaces which are part of the directory name

const repoPath = path.normalize(result.stdout.trimLeft().replace(/[\r\n]+$/, ''));

if (isWindows) {

// On Git 2.25+ if you call `rev-parse --show-toplevel` on a mapped drive, instead of getting the mapped drive path back, you get the UNC path for the mapped drive.

// So we will try to normalize it back to the mapped drive path, if possible

const repoUri = Uri.file(repoPath);

const pathUri = Uri.file(repositoryPath);

if (repoUri.authority.length !== 0 && pathUri.authority.length === 0) {

let match = /(?<=^\/?)([a-zA-Z])(?=:\/)/.exec(pathUri.path);

if (match !== null) {

const [, letter] = match;

try {

const networkPath = await new Promise<string>(resolve =>

realpath.native(`${letter}:`, { encoding: 'utf8' }, (err, resolvedPath) =>

// eslint-disable-next-line eqeqeq

resolve(err != null ? undefined : resolvedPath),

),

);

if (networkPath !== undefined) {

return path.normalize(

repoUri.fsPath.replace(

networkPath,

`${letter.toLowerCase()}:${networkPath.endsWith('\\') ? '\\' : ''}`

),

);

}

} catch { }

}

return path.normalize(pathUri.fsPath);

}

}

return repoPath;

}

async getRepositoryDotGit(repositoryPath: string): Promise<string> {

const result = await this.exec(repositoryPath, ['rev-parse', '--git-dir']);

let dotGitPath = result.stdout.trim();

if (!path.isAbsolute(dotGitPath)) {

dotGitPath = path.join(repositoryPath, dotGitPath);

}

return path.normalize(dotGitPath);

}

async exec(cwd: string, args: string[], options: SpawnOptions = {}): Promise<IExecutionResult<string>> {

options = assign({ cwd }, options || {});

return await this._exec(args, options);

}

async exec2(args: string[], options: SpawnOptions = {}): Promise<IExecutionResult<string>> {

return await this._exec(args, options);

}

stream(cwd: string, args: string[], options: SpawnOptions = {}): cp.ChildProcess {

options = assign({ cwd }, options || {});

return this.spawn(args, options);

}

private async _exec(args: string[], options: SpawnOptions = {}): Promise<IExecutionResult<string>> {

const child = this.spawn(args, options);

if (options.onSpawn) {

options.onSpawn(child);

}

if (options.input) {

child.stdin!.end(options.input, 'utf8');

}

const bufferResult = await exec(child, options.cancellationToken);

if (options.log !== false && bufferResult.stderr.length > 0) {

this.log(`${bufferResult.stderr}\n`);

}

let encoding = options.encoding || 'utf8';

encoding = iconv.encodingExists(encoding) ? encoding : 'utf8';

const result: IExecutionResult<string> = {

exitCode: bufferResult.exitCode,

stdout: iconv.decode(bufferResult.stdout, encoding),

stderr: bufferResult.stderr

};

if (bufferResult.exitCode) {

return Promise.reject<IExecutionResult<string>>(new GitError({

message: 'Failed to execute git',

stdout: result.stdout,

stderr: result.stderr,

exitCode: result.exitCode,

gitErrorCode: getGitErrorCode(result.stderr),

gitCommand: args[0]

}));

}

return result;

}

spawn(args: string[], options: SpawnOptions = {}): cp.ChildProcess {

if (!this.path) {

throw new Error('git could not be found in the system.');

}

if (!options) {

options = {};

}

if (!options.stdio && !options.input) {

options.stdio = ['ignore', null, null]; // Unless provided, ignore stdin and leave default streams for stdout and stderr

}

options.env = assign({}, process.env, this.env, options.env || {}, {

VSCODE_GIT_COMMAND: args[0],

LC_ALL: 'en_US.UTF-8',

LANG: 'en_US.UTF-8',

GIT_PAGER: 'cat'

});

if (options.cwd) {

options.cwd = sanitizePath(options.cwd);

}

if (options.log !== false) {

this.log(`> git ${args.join(' ')}\n`);

}

return cp.spawn(this.path, args, options);

}

private log(output: string): void {

this._onOutput.emit('log', output);

}

hash: string;

message: string;

parents: string[];

authorDate?: Date;

authorName?: string;

authorEmail?: string;

commitDate?: Date;

private lastRaw = '';

private result: IFileStatus[] = [];

get status(): IFileStatus[] {

return this.result;

}

update(raw: string): void {

let i = 0;

let nextI: number | undefined;

raw = this.lastRaw + raw;

while ((nextI = this.parseEntry(raw, i)) !== undefined) {

i = nextI;

}

this.lastRaw = raw.substr(i);

}

private parseEntry(raw: string, i: number): number | undefined {

if (i + 4 >= raw.length) {

return;

}

let lastIndex: number;

const entry: IFileStatus = {

x: raw.charAt(i++),

y: raw.charAt(i++),

rename: undefined,

path: ''

};

// space

i++;

if (entry.x === 'R' || entry.x === 'C') {

lastIndex = raw.indexOf('\0', i);

if (lastIndex === -1) {

return;

}

entry.rename = raw.substring(i, lastIndex);

i = lastIndex + 1;

}

lastIndex = raw.indexOf('\0', i);

if (lastIndex === -1) {

return;

}

entry.path = raw.substring(i, lastIndex);

// If path ends with slash, it must be a nested git repo

if (entry.path[entry.path.length - 1] !== '/') {

this.result.push(entry);

}

return lastIndex + 1;

}

name: string;

path: string;

url: string;

const regex = /\r?\n/g;

let position = 0;

let match: RegExpExecArray | null = null;

const result: Submodule[] = [];

let submodule: Partial<Submodule> = {};