FilesExpand file tree

main

/

builtinGit.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

78 lines (66 loc) · 3.02 KB

main

/

builtinGit.ts

Copy path

Top

File metadata and controls

• Code
• Blame

78 lines (66 loc) · 3.02 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

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

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

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

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

import * as vscode from 'vscode';

import { APIState, CloneOptions, GitAPI, GitExtension, PublishEvent } from '../@types/git';

import { IGit, Repository } from '../api/api';

import { commands } from '../common/executeCommands';

import { Disposable } from '../common/lifecycle';

export class BuiltinGitProvider extends Disposable implements IGit {

get repositories(): Repository[] {

return this._gitAPI.repositories as any[];

}

get state(): APIState {

return this._gitAPI.state;

}

private _onDidOpenRepository = new vscode.EventEmitter<Repository>();

readonly onDidOpenRepository: vscode.Event<Repository> = this._onDidOpenRepository.event;

private _onDidCloseRepository = new vscode.EventEmitter<Repository>();

readonly onDidCloseRepository: vscode.Event<Repository> = this._onDidCloseRepository.event;

private _onDidChangeState = new vscode.EventEmitter<APIState>();

readonly onDidChangeState: vscode.Event<APIState> = this._onDidChangeState.event;

private _onDidPublish = new vscode.EventEmitter<PublishEvent>();

readonly onDidPublish: vscode.Event<PublishEvent> = this._onDidPublish.event;

private readonly _gitAPI: GitAPI;

private constructor(extension: vscode.Extension<GitExtension>) {

super();

const gitExtension = extension.exports;

try {

this._gitAPI = gitExtension.getAPI(1);

} catch (e) {

// The git extension will throw if a git model cannot be found, i.e. if git is not installed.

commands.setContext('gitNotInstalled', true);

throw e;

}

this._register(this._gitAPI.onDidCloseRepository(e => this._onDidCloseRepository.fire(e)));

this._register(this._gitAPI.onDidOpenRepository(e => this._onDidOpenRepository.fire(e)));

this._register(this._gitAPI.onDidChangeState(e => this._onDidChangeState.fire(e)));

this._register(this._gitAPI.onDidPublish(e => this._onDidPublish.fire(e)));

}

getRepositoryWorkspace(uri: vscode.Uri): Promise<vscode.Uri[] | null> {

return this._gitAPI.getRepositoryWorkspace(uri);

}

openWorktreeRepository(uri: vscode.Uri): Promise<Repository | null> {

return this._gitAPI.openRepository(uri);

}

clone(uri: vscode.Uri, options?: CloneOptions): Promise<vscode.Uri | null> {

return this._gitAPI.clone(uri, options);

}

static async createProvider(): Promise<BuiltinGitProvider | undefined> {

const extension = vscode.extensions.getExtension<GitExtension>('vscode.git');

if (extension) {

await extension.activate();

return new BuiltinGitProvider(extension);

}

return undefined;

}

registerPostCommitCommandsProvider?(provider: any): vscode.Disposable {

if (this._gitAPI.registerPostCommitCommandsProvider) {

return this._gitAPI.registerPostCommitCommandsProvider(provider);

}

return {

dispose: () => { }

};

}

}