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

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

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

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

import { promises as fs, exists, realpath } from 'fs';

import * as path from 'path';

import * as os from 'os';

import * as cp from 'child_process';

import * as which from 'which';

import { EventEmitter } from 'events';

import * as iconv from 'iconv-lite-umd';

import * as filetype from 'file-type';

import { assign, groupBy, IDisposable, toDisposable, dispose, mkdirp, readBytes, detectUnicodeEncoding, Encoding, onceEvent, splitInChunks, Limiter } from './util';

import { CancellationToken, Progress, Uri } from 'vscode';

import { URI } from 'vscode-uri';

import { detectEncoding } from './encoding';

import { Ref, RefType, Branch, Remote, GitErrorCodes, LogOptions, Change, Status, CommitOptions, BranchQuery } from './api/git';

import * as byline from 'byline';

import { StringDecoder } from 'string_decoder';

// https://github.com/microsoft/vscode/issues/65693

const MAX_CLI_LENGTH = 30000;

const isWindows = process.platform === 'win32';

export interface IGit {

path: string;

version: string;

}

export interface IFileStatus {

x: string;

y: string;

path: string;

rename?: string;

}

export interface Stash {

index: number;

description: string;

}

interface MutableRemote extends Remote {

fetchUrl?: string;

pushUrl?: string;

isReadOnly: boolean;

}

// TODO@eamodio: Move to git.d.ts once we are good with the api

/**

* Log file options.

*/

export interface LogFileOptions {

/** 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;

}

function parseVersion(raw: string): string {

return raw.replace(/^git version /, '');

}

function findSpecificGit(path: string, onLookup: (path: string) => void): Promise<IGit> {

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

});

}

function findGitDarwin(onLookup: (path: string) => void): Promise<IGit> {

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

});

});

});

}

function findSystemGitWin32(base: string, onLookup: (path: string) => void): Promise<IGit> {

if (!base) {

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

}

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

}

function findGitWin32InPath(onLookup: (path: string) => void): Promise<IGit> {

const whichPromise = new Promise<string>((c, e) => which('git.exe', (err, path) => err ? e(err) : c(path)));

return whichPromise.then(path => findSpecificGit(path, onLookup));

}

function findGitWin32(onLookup: (path: string) => void): Promise<IGit> {

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

}

export async function findGit(hint: string | string[] | undefined, onLookup: (path: string) => void): Promise<IGit> {

const hints = Array.isArray(hint) ? hint : hint ? [hint] : [];

for (const hint of hints) {

try {

return await findSpecificGit(hint, onLookup);

} catch {

// noop

}

}

try {

switch (process.platform) {

case 'darwin': return await findGitDarwin(onLookup);

case 'win32': return await findGitWin32(onLookup);

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

}

} catch {

// noop

}

throw new Error('Git installation not found.');

}

export interface IExecutionResult<T extends string | Buffer> {

exitCode: number;

stdout: T;

stderr: string;

}

function cpErrorHandler(cb: (reason?: any) => void): (reason?: any) => void {

return err => {

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

err = new GitError({

error: err,

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

gitErrorCode: GitErrorCodes.NotAGitRepository

});

}

cb(err);

};

}

export interface SpawnOptions extends cp.SpawnOptions {

input?: string;

encoding?: string;

log?: boolean;

cancellationToken?: CancellationToken;

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

}

async function exec(child: cp.ChildProcess, cancellationToken?: CancellationToken): Promise<IExecutionResult<Buffer>> {

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

}

}

export interface IGitErrorData {

error?: Error;

message?: string;

stdout?: string;

stderr?: string;

exitCode?: number;

gitErrorCode?: string;

gitCommand?: string;

}

export class GitError {

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;

}

}

export interface IGitOptions {

gitPath: string;

version: string;

env?: any;

}

function getGitErrorCode(stderr: string): string | undefined {

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;

}

// https://github.com/microsoft/vscode/issues/89373

// https://github.com/git-for-windows/git/issues/2478

function sanitizePath(path: string): string {

return path.replace(/^([a-z]):\\/i, (_, letter) => `${letter.toUpperCase()}:\\`);

}

const COMMIT_FORMAT = '%H%n%aN%n%aE%n%at%n%ct%n%P%n%B';

export class Git {

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'], { log: false });

// 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 | undefined>(resolve =>

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

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

}

}

export interface Commit {

hash: string;

message: string;

parents: string[];

authorDate?: Date;

authorName?: string;

authorEmail?: string;

commitDate?: Date;

}

export class GitStatusParser {

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;

}

}

export interface Submodule {

name: string;

path: string;

url: string;

}

export function parseGitmodules(raw: string): Submodule[] {

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

let position = 0;

let match: RegExpExecArray | null = null;

const result: Submodule[] = [];

let submodule: Partial<Submodule> = {};

function parseLine(line: string): void {

const sectionMatch = /^\s*\[submodule "([^"]+)"\]\s*$/.exec(line);

if (sectionMatch) {

if (submodule.name && submodule.path && submodule.url) {

result.push(submodule as Submodule);

}

const name = sectionMatch[1];

if (name) {

submodule = { name };

return;

}

}

if (!submodule) {

return;

}

const propertyMatch = /^\s*(\w+)\s+=\s+(.*)$/.exec(line);

if (!propertyMatch) {

return;

}

const [, key, value] = propertyMatch;

switch (key) {

case 'path': submodule.path = value; break;

case 'url': submodule.url = value; break;

}

}

while (match = regex.exec(raw)) {

parseLine(raw.substring(position, match.index));

position = match.index + match[0].length;

}

parseLine(raw.substring(position));

if (submodule.name && submodule.path && submodule.url) {

result.push(submodule as Submodule);

}

return result;

}

const commitRegex = /([0-9a-f]{40})\n(.*)\n(.*)\n(.*)\n(.*)\n(.*)(?:\n([^]*?))?(?:\x00)/gm;

export function parseGitCommits(data: string): Commit[] {

let commits: Commit[] = [];

let ref;

let authorName;

let authorEmail;

let authorDate;

let commitDate;

let parents;

let message;

let match;

do {

match = commitRegex.exec(data);

if (match === null) {

break;

}

[, ref, authorName, authorEmail, authorDate, commitDate, parents, message] = match;

if (message[message.length - 1] === '\n') {

message = message.substr(0, message.length - 1);

}

// Stop excessive memory usage by using substr -- https://bugs.chromium.org/p/v8/issues/detail?id=2869

commits.push({

hash: ` ${ref}`.substr(1),

message: ` ${message}`.substr(1),

parents: parents ? parents.split(' ') : [],

authorDate: new Date(Number(authorDate) * 1000),

authorName: ` ${authorName}`.substr(1),

authorEmail: ` ${authorEmail}`.substr(1),

commitDate: new Date(Number(commitDate) * 1000),

});

} while (true);

return commits;

}

interface LsTreeElement {

mode: string;

type: string;

object: string;

size: string;

file: string;

}

export function parseLsTree(raw: string): LsTreeElement[] {

return raw.split('\n')

.filter(l => !!l)

.map(line => /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*)$/.exec(line)!)

.filter(m => !!m)

.map(([, mode, type, object, size, file]) => ({ mode, type, object, size, file }));

}

interface LsFilesElement {

mode: string;

object: string;

stage: string;

file: string;

}

export function parseLsFiles(raw: string): LsFilesElement[] {

return raw.split('\n')

.filter(l => !!l)

.map(line => /^(\S+)\s+(\S+)\s+(\S+)\s+(.*)$/.exec(line)!)

.filter(m => !!m)

.map(([, mode, object, stage, file]) => ({ mode, object, stage, file }));

}

export interface PullOptions {

unshallow?: boolean;

tags?: boolean;

readonly cancellationToken?: CancellationToken;

}

export enum ForcePushMode {

Force,

ForceWithLease

}

export class Repository {

constructor(

private _git: Git,

private repositoryRoot: string,

readonly dotGit: string

) { }

get git(): Git {

return this._git;

}

get root(): string {

return this.repositoryRoot;

}

// TODO@Joao: rename to exec

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

return await this.git.exec(this.repositoryRoot, args, options);

}

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

return this.git.stream(this.repositoryRoot, args, options);

}

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

return this.git.spawn(args, options);

}

async config(scope: string, key: string, value: any = null, options: SpawnOptions = {}): Promise<string> {

const args = ['config'];

if (scope) {

args.push('--' + scope);

}

args.push(key);

if (value) {

args.push(value);

}

const result = await this.run(args, options);

return result.stdout.trim();

}

async getConfigs(scope: string): Promise<{ key: string; value: string; }[]> {

const args = ['config'];

if (scope) {

args.push('--' + scope);

}

args.push('-l');

const result = await this.run(args);

const lines = result.stdout.trim().split(/\r|\r\n|\n/);

return lines.map(entry => {

const equalsIndex = entry.indexOf('=');

return { key: entry.substr(0, equalsIndex), value: entry.substr(equalsIndex + 1) };

});

}

async log(options?: LogOptions): Promise<Commit[]> {

const maxEntries = options?.maxEntries ?? 32;

const args = ['log', `-n${maxEntries}`, `--format=${COMMIT_FORMAT}`, '-z', '--'];

if (options?.path) {

args.push(options.path);

}

const result = await this.run(args);

if (result.exitCode) {

// An empty repo

return [];

}

return parseGitCommits(result.stdout);

}

async logFile(uri: Uri, options?: LogFileOptions): Promise<Commit[]> {

const args = ['log', `--format=${COMMIT_FORMAT}`, '-z'];

if (options?.maxEntries && !options?.reverse) {

args.push(`-n${options.maxEntries}`);

}

if (options?.hash) {

// If we are reversing, we must add a range (with HEAD) because we are using --ancestry-path for better reverse walking

if (options?.reverse) {

args.push('--reverse', '--ancestry-path', `${options.hash}..HEAD`);

} else {

args.push(options.hash);

}

}

if (options?.sortByAuthorDate) {

args.push('--author-date-order');

}

args.push('--', uri.fsPath);

const result = await this.run(args);

if (result.exitCode) {

// No file history, e.g. a new file or untracked

return [];

}

return parseGitCommits(result.stdout);

}

async bufferString(object: string, encoding: string = 'utf8', autoGuessEncoding = false): Promise<string> {

const stdout = await this.buffer(object);

if (autoGuessEncoding) {

encoding = detectEncoding(stdout) || encoding;

}

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

return iconv.decode(stdout, encoding);

}

async buffer(object: string): Promise<Buffer> {

const child = this.stream(['show', '--textconv', object]);

if (!child.stdout) {

return Promise.reject<Buffer>('Can\'t open file from git');

}

const { exitCode, stdout, stderr } = await exec(child);

if (exitCode) {

const err = new GitError({

message: 'Could not show object.',

exitCode

});

if (/exists on disk, but not in/.test(stderr)) {

err.gitErrorCode = GitErrorCodes.WrongCase;

}

return Promise.reject<Buffer>(err);

}

return stdout;

}

async getObjectDetails(treeish: string, path: string): Promise<{ mode: string, object: string, size: number }> {

if (!treeish) { // index

const elements = await this.lsfiles(path);

if (elements.length === 0) {

throw new GitError({ message: 'Path not known by git', gitErrorCode: GitErrorCodes.UnknownPath });

}

const { mode, object } = elements[0];

const catFile = await this.run(['cat-file', '-s', object]);

const size = parseInt(catFile.stdout);

return { mode, object, size };

}

const elements = await this.lstree(treeish, path);

if (elements.length === 0) {

throw new GitError({ message: 'Path not known by git', gitErrorCode: GitErrorCodes.UnknownPath });

}

const { mode, object, size } = elements[0];

return { mode, object, size: parseInt(size) };

}

async lstree(treeish: string, path: string): Promise<LsTreeElement[]> {

const { stdout } = await this.run(['ls-tree', '-l', treeish, '--', sanitizePath(path)]);

return parseLsTree(stdout);

}

async lsfiles(path: string): Promise<LsFilesElement[]> {

const { stdout } = await this.run(['ls-files', '--stage', '--', sanitizePath(path)]);

return parseLsFiles(stdout);

}

async getGitRelativePath(ref: string, relativePath: string): Promise<string> {

const relativePathLowercase = relativePath.toLowerCase();

const dirname = path.posix.dirname(relativePath) + '/';

const elements: { file: string; }[] = ref ? await this.lstree(ref, dirname) : await this.lsfiles(dirname);

const element = elements.filter(file => file.file.toLowerCase() === relativePathLowercase)[0];

if (!element) {

throw new GitError({ message: 'Git relative path not found.' });

}

return element.file;

}

async detectObjectType(object: string): Promise<{ mimetype: string, encoding?: string }> {

const child = await this.stream(['show', '--textconv', object]);

const buffer = await readBytes(child.stdout!, 4100);

try {

child.kill();

} catch (err) {

// noop

}

const encoding = detectUnicodeEncoding(buffer);

let isText = true;