Merge branch 'master' into gitcloneissue

extensions/git/src/api/api1.ts

@@ -167,6 +167,10 @@ export class ApiRepository implements Repository {
 	pull(): Promise<void> {
 		return this._repository.pull();
 	}
+
+	push(remoteName?: string, branchName?: string, setUpstream: boolean = false): Promise<void> {
+		return this._repository.pushTo(remoteName, branchName, setUpstream);
+	}
 }
 
 export class ApiGit implements Git {

extensions/git/src/api/extension.ts

@@ -6,6 +6,8 @@
 import { Model } from '../model';
 import { GitExtension, Repository, API } from './git';
 import { ApiRepository, ApiImpl } from './api1';
+import { Event, EventEmitter } from 'vscode';
+import { latchEvent } from '../util';
 
 export function deprecated(_target: any, key: string, descriptor: any): void {
 	if (typeof descriptor.value !== 'function') {
@@ -19,50 +21,56 @@ export function deprecated(_target: any, key: string, descriptor: any): void {
 	};
 }
 
-class NoModelGitExtension implements GitExtension {
+export class GitExtensionImpl implements GitExtension {
+
+	enabled: boolean = false;
+
+	private _onDidChangeEnablement = new EventEmitter<boolean>();
+	readonly onDidChangeEnablement: Event<boolean> = latchEvent(this._onDidChangeEnablement.event);
+
+	private _model: Model | undefined = undefined;
+
+	set model(model: Model | undefined) {
+		this._model = model;
+
+		this.enabled = !!model;
+		this._onDidChangeEnablement.fire(this.enabled);
+	}
+
+	constructor(model?: Model) {
+		if (model) {
+			this.enabled = true;
+			this._model = model;
+		}
+	}
 
 	@deprecated
 	async getGitPath(): Promise<string> {
-		throw new Error('Git model not found');
-	}
+		if (!this._model) {
+			throw new Error('Git model not found');
+		}
 
-	@deprecated
-	async getRepositories(): Promise<Repository[]> {
-		throw new Error('Git model not found');
-	}
-
-	getAPI(): API {
-		throw new Error('Git model not found');
-	}
-}
-
-class GitExtensionImpl implements GitExtension {
-
-	constructor(private _model: Model) { }
-
-	@deprecated
-	async getGitPath(): Promise<string> {
 		return this._model.git.path;
 	}
 
 	@deprecated
 	async getRepositories(): Promise<Repository[]> {
+		if (!this._model) {
+			throw new Error('Git model not found');
+		}
+
 		return this._model.repositories.map(repository => new ApiRepository(repository));
 	}
 
 	getAPI(version: number): API {
+		if (!this._model) {
+			throw new Error('Git model not found');
+		}
+
 		if (version !== 1) {
 			throw new Error(`No API version ${version} found.`);
 		}
 
 		return new ApiImpl(this._model);
 	}
-}
-
-export function createGitExtension(model?: Model): GitExtension {
-	if (!model) {
-		return new NoModelGitExtension();
-	}
-
-	return new GitExtensionImpl(model);
-}
+}

extensions/git/src/api/git.d.ts

@@ -152,6 +152,7 @@ export interface Repository {
 
 	fetch(remote?: string, ref?: string): Promise<void>;
 	pull(): Promise<void>;
+	push(remoteName?: string, branchName?: string, setUpstream?: boolean): Promise<void>;
 }
 
 export interface API {
@@ -163,9 +164,16 @@ export interface API {
 
 export interface GitExtension {
 
+	readonly enabled: boolean;
+	readonly onDidChangeEnablement: Event<boolean>;
+
 	/**
 	 * Returns a specific API version.
 	 *
+	 * Throws error if git extension is disabled. You can listed to the
+	 * [GitExtension.onDidChangeEnablement](#GitExtension.onDidChangeEnablement) event
+	 * to know when the extension becomes enabled/disabled.
+	 *
 	 * @param version Version number.
 	 * @returns API instance
 	 */

extensions/git/src/commands.ts

@@ -646,6 +646,7 @@ export class CommandCenter {
 	@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;
@@ -666,12 +667,18 @@ export class CommandCenter {
 			return;
 		}
 
-		return await commands.executeCommand<void>('vscode.open', HEAD);
+		const opts: TextDocumentShowOptions = {
+			preview
+		};
+
+		return await commands.executeCommand<void>('vscode.open', HEAD, opts);
 	}
 
 	@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;
 
@@ -698,7 +705,6 @@ export class CommandCenter {
 			return;
 		}
 
-		const preview = resources.length === 1 ? undefined : false;
 		for (const resource of resources) {
 			await this._openResource(resource, preview, preserveFocus, preserveSelection);
 		}

extensions/git/src/main.ts

@@ -17,7 +17,7 @@ import { toDisposable, filterEvent, eventToPromise } from './util';
 import TelemetryReporter from 'vscode-extension-telemetry';
 import { GitExtension } from './api/git';
 import { GitProtocolHandler } from './protocolHandler';
-import { createGitExtension } from './api/extension';
+import { GitExtensionImpl } from './api/extension';
 import * as path from 'path';
 import * as fs from 'fs';
 
@@ -137,12 +137,15 @@ export async function activate(context: ExtensionContext): Promise<GitExtension>
 	if (!enabled) {
 		const onConfigChange = filterEvent(workspace.onDidChangeConfiguration, e => e.affectsConfiguration('git'));
 		const onEnabled = filterEvent(onConfigChange, () => workspace.getConfiguration('git', null).get<boolean>('enabled') === true);
-		await eventToPromise(onEnabled);
+		const result = new GitExtensionImpl();
+
+		eventToPromise(onEnabled).then(async () => result.model = await createModel(context, outputChannel, telemetryReporter, disposables));
+		return result;
 	}
 
 	try {
 		const model = await createModel(context, outputChannel, telemetryReporter, disposables);
-		return createGitExtension(model);
+		return new GitExtensionImpl(model);
 	} catch (err) {
 		if (!/Git installation not found/.test(err.message || '')) {
 			throw err;
@@ -151,9 +154,9 @@ export async function activate(context: ExtensionContext): Promise<GitExtension>
 		console.warn(err.message);
 		outputChannel.appendLine(err.message);
 
-		await warnAboutMissingGit();
+		warnAboutMissingGit();
 
-		return createGitExtension();
+		return new GitExtensionImpl();
 	}
 }
 

extensions/git/src/repository.ts

@@ -829,7 +829,7 @@ export class Repository implements Disposable {
 	}
 
 	async branch(name: string, _checkout: boolean, _ref?: string): Promise<void> {
-		await this.run(Operation.Branch, () => this.repository.branch(name, true));
+		await this.run(Operation.Branch, () => this.repository.branch(name, _checkout, _ref));
 	}
 
 	async deleteBranch(name: string, force?: boolean): Promise<void> {

extensions/git/src/util.ts

@@ -44,6 +44,18 @@ export function filterEvent<T>(event: Event<T>, filter: (e: T) => boolean): Even
 	return (listener, thisArgs = null, disposables?) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables);
 }
 
+export function latchEvent<T>(event: Event<T>): Event<T> {
+	let firstCall = true;
+	let cache: T;
+
+	return filterEvent(event, value => {
+		let shouldEmit = firstCall || value !== cache;
+		firstCall = false;
+		cache = value;
+		return shouldEmit;
+	});
+}
+
 export function anyEvent<T>(...events: Event<T>[]): Event<T> {
 	return (listener, thisArgs = null, disposables?) => {
 		const result = combinedDisposable(events.map(event => event(i => listener.call(thisArgs, i))));