Last active
April 14, 2023 01:06
-
-
Save sandipchitale/db5ebd075f2155006ec630ff2bdc386a to your computer and use it in GitHub Desktop.
vscode-git #vscode-git
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
import * as path from 'path'; | |
import * as vscode from 'vscode'; | |
import { GitExtension, API } from './git'; | |
let git: API; | |
let workspaceFolder: vscode.WorkspaceFolder; | |
export function activate(context: vscode.ExtensionContext) { | |
context.subscriptions.push(vscode.commands.registerCommand('vscode-git-teamcity-remote-run.remote-run', remoteRun)); | |
if (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0) { | |
workspaceFolder = vscode.workspace.workspaceFolders[0]; | |
} | |
const gitExtension = vscode.extensions.getExtension<GitExtension>('vscode.git')?.exports; | |
if (gitExtension) { | |
git = gitExtension.getAPI(1); | |
} | |
} | |
async function remoteRun(target: any) { | |
if (git && workspaceFolder) { | |
const repository = git.getRepository(workspaceFolder.uri); | |
if (repository) { | |
console.log(`Branch: ${repository.state.HEAD?.name}`); | |
repository.state.indexChanges.forEach((change) => { | |
if (change.uri.fsPath.startsWith(workspaceFolder.uri.fsPath)) { | |
console.log(`Local run: ${path.relative(workspaceFolder.uri.fsPath, change.uri.fsPath)}`); | |
} | |
}); | |
} | |
} | |
} | |
export function deactivate() {} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/*--------------------------------------------------------------------------------------------- | |
* Copyright (c) Microsoft Corporation. All rights reserved. | |
* Licensed under the MIT License. See License.txt in the project root for license information. | |
*--------------------------------------------------------------------------------------------*/ | |
import { Uri, Event, Disposable, ProviderResult, Command, CancellationToken } from 'vscode'; | |
export { ProviderResult } from 'vscode'; | |
export interface Git { | |
readonly path: string; | |
} | |
export interface InputBox { | |
value: string; | |
} | |
export const enum ForcePushMode { | |
Force, | |
ForceWithLease | |
} | |
export const enum RefType { | |
Head, | |
RemoteHead, | |
Tag | |
} | |
export interface Ref { | |
readonly type: RefType; | |
readonly name?: string; | |
readonly commit?: string; | |
readonly remote?: string; | |
} | |
export interface UpstreamRef { | |
readonly remote: string; | |
readonly name: string; | |
} | |
export interface Branch extends Ref { | |
readonly upstream?: UpstreamRef; | |
readonly ahead?: number; | |
readonly behind?: number; | |
} | |
export interface Commit { | |
readonly hash: string; | |
readonly message: string; | |
readonly parents: string[]; | |
readonly authorDate?: Date; | |
readonly authorName?: string; | |
readonly authorEmail?: string; | |
readonly commitDate?: Date; | |
} | |
export interface Submodule { | |
readonly name: string; | |
readonly path: string; | |
readonly url: string; | |
} | |
export interface Remote { | |
readonly name: string; | |
readonly fetchUrl?: string; | |
readonly pushUrl?: string; | |
readonly isReadOnly: boolean; | |
} | |
export const enum Status { | |
INDEX_MODIFIED, | |
INDEX_ADDED, | |
INDEX_DELETED, | |
INDEX_RENAMED, | |
INDEX_COPIED, | |
MODIFIED, | |
DELETED, | |
UNTRACKED, | |
IGNORED, | |
INTENT_TO_ADD, | |
ADDED_BY_US, | |
ADDED_BY_THEM, | |
DELETED_BY_US, | |
DELETED_BY_THEM, | |
BOTH_ADDED, | |
BOTH_DELETED, | |
BOTH_MODIFIED | |
} | |
export interface Change { | |
/** | |
* Returns either `originalUri` or `renameUri`, depending | |
* on whether this change is a rename change. When | |
* in doubt always use `uri` over the other two alternatives. | |
*/ | |
readonly uri: Uri; | |
readonly originalUri: Uri; | |
readonly renameUri: Uri | undefined; | |
readonly status: Status; | |
} | |
export interface RepositoryState { | |
readonly HEAD: Branch | undefined; | |
readonly refs: Ref[]; | |
readonly remotes: Remote[]; | |
readonly submodules: Submodule[]; | |
readonly rebaseCommit: Commit | undefined; | |
readonly mergeChanges: Change[]; | |
readonly indexChanges: Change[]; | |
readonly workingTreeChanges: Change[]; | |
readonly onDidChange: Event<void>; | |
} | |
export interface RepositoryUIState { | |
readonly selected: boolean; | |
readonly onDidChange: Event<void>; | |
} | |
/** | |
* Log options. | |
*/ | |
export interface LogOptions { | |
/** Max number of log entries to retrieve. If not specified, the default is 32. */ | |
readonly maxEntries?: number; | |
readonly path?: string; | |
} | |
export interface CommitOptions { | |
all?: boolean | 'tracked'; | |
amend?: boolean; | |
signoff?: boolean; | |
signCommit?: boolean; | |
empty?: boolean; | |
noVerify?: boolean; | |
requireUserConfig?: boolean; | |
useEditor?: boolean; | |
verbose?: boolean; | |
/** | |
* string - execute the specified command after the commit operation | |
* undefined - execute the command specified in git.postCommitCommand | |
* after the commit operation | |
* null - do not execute any command after the commit operation | |
*/ | |
postCommitCommand?: string | null; | |
} | |
export interface FetchOptions { | |
remote?: string; | |
ref?: string; | |
all?: boolean; | |
prune?: boolean; | |
depth?: number; | |
} | |
export interface RefQuery { | |
readonly contains?: string; | |
readonly count?: number; | |
readonly pattern?: string; | |
readonly sort?: 'alphabetically' | 'committerdate'; | |
} | |
export interface BranchQuery extends RefQuery { | |
readonly remote?: boolean; | |
} | |
export interface Repository { | |
readonly rootUri: Uri; | |
readonly inputBox: InputBox; | |
readonly state: RepositoryState; | |
readonly ui: RepositoryUIState; | |
getConfigs(): Promise<{ key: string; value: string; }[]>; | |
getConfig(key: string): Promise<string>; | |
setConfig(key: string, value: string): Promise<string>; | |
getGlobalConfig(key: string): Promise<string>; | |
getObjectDetails(treeish: string, path: string): Promise<{ mode: string, object: string, size: number }>; | |
detectObjectType(object: string): Promise<{ mimetype: string, encoding?: string }>; | |
buffer(ref: string, path: string): Promise<Buffer>; | |
show(ref: string, path: string): Promise<string>; | |
getCommit(ref: string): Promise<Commit>; | |
add(paths: string[]): Promise<void>; | |
revert(paths: string[]): Promise<void>; | |
clean(paths: string[]): Promise<void>; | |
apply(patch: string, reverse?: boolean): Promise<void>; | |
diff(cached?: boolean): Promise<string>; | |
diffWithHEAD(): Promise<Change[]>; | |
diffWithHEAD(path: string): Promise<string>; | |
diffWith(ref: string): Promise<Change[]>; | |
diffWith(ref: string, path: string): Promise<string>; | |
diffIndexWithHEAD(): Promise<Change[]>; | |
diffIndexWithHEAD(path: string): Promise<string>; | |
diffIndexWith(ref: string): Promise<Change[]>; | |
diffIndexWith(ref: string, path: string): Promise<string>; | |
diffBlobs(object1: string, object2: string): Promise<string>; | |
diffBetween(ref1: string, ref2: string): Promise<Change[]>; | |
diffBetween(ref1: string, ref2: string, path: string): Promise<string>; | |
hashObject(data: string): Promise<string>; | |
createBranch(name: string, checkout: boolean, ref?: string): Promise<void>; | |
deleteBranch(name: string, force?: boolean): Promise<void>; | |
getBranch(name: string): Promise<Branch>; | |
getBranches(query: BranchQuery, cancellationToken?: CancellationToken): Promise<Ref[]>; | |
setBranchUpstream(name: string, upstream: string): Promise<void>; | |
getRefs(query: RefQuery, cancellationToken?: CancellationToken): Promise<Ref[]>; | |
getMergeBase(ref1: string, ref2: string): Promise<string>; | |
tag(name: string, upstream: string): Promise<void>; | |
deleteTag(name: string): Promise<void>; | |
status(): Promise<void>; | |
checkout(treeish: string): Promise<void>; | |
addRemote(name: string, url: string): Promise<void>; | |
removeRemote(name: string): Promise<void>; | |
renameRemote(name: string, newName: string): Promise<void>; | |
fetch(options?: FetchOptions): Promise<void>; | |
fetch(remote?: string, ref?: string, depth?: number): Promise<void>; | |
pull(unshallow?: boolean): Promise<void>; | |
push(remoteName?: string, branchName?: string, setUpstream?: boolean, force?: ForcePushMode): Promise<void>; | |
blame(path: string): Promise<string>; | |
log(options?: LogOptions): Promise<Commit[]>; | |
commit(message: string, opts?: CommitOptions): Promise<void>; | |
} | |
export interface RemoteSource { | |
readonly name: string; | |
readonly description?: string; | |
readonly url: string | string[]; | |
} | |
export interface RemoteSourceProvider { | |
readonly name: string; | |
readonly icon?: string; // codicon name | |
readonly supportsQuery?: boolean; | |
getRemoteSources(query?: string): ProviderResult<RemoteSource[]>; | |
getBranches?(url: string): ProviderResult<string[]>; | |
publishRepository?(repository: Repository): Promise<void>; | |
} | |
export interface RemoteSourcePublisher { | |
readonly name: string; | |
readonly icon?: string; // codicon name | |
publishRepository(repository: Repository): Promise<void>; | |
} | |
export interface Credentials { | |
readonly username: string; | |
readonly password: string; | |
} | |
export interface CredentialsProvider { | |
getCredentials(host: Uri): ProviderResult<Credentials>; | |
} | |
export interface PostCommitCommandsProvider { | |
getCommands(repository: Repository): Command[]; | |
} | |
export interface PushErrorHandler { | |
handlePushError(repository: Repository, remote: Remote, refspec: string, error: Error & { gitErrorCode: GitErrorCodes }): Promise<boolean>; | |
} | |
export interface BranchProtectionProvider { | |
onDidChangeBranchProtection: Event<Uri>; | |
provideBranchProtection(): Map<string, string[]>; | |
} | |
export type APIState = 'uninitialized' | 'initialized'; | |
export interface PublishEvent { | |
repository: Repository; | |
branch?: string; | |
} | |
export interface API { | |
readonly state: APIState; | |
readonly onDidChangeState: Event<APIState>; | |
readonly onDidPublish: Event<PublishEvent>; | |
readonly git: Git; | |
readonly repositories: Repository[]; | |
readonly onDidOpenRepository: Event<Repository>; | |
readonly onDidCloseRepository: Event<Repository>; | |
toGitUri(uri: Uri, ref: string): Uri; | |
getRepository(uri: Uri): Repository | null; | |
init(root: Uri): Promise<Repository | null>; | |
openRepository(root: Uri): Promise<Repository | null> | |
registerRemoteSourcePublisher(publisher: RemoteSourcePublisher): Disposable; | |
registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable; | |
registerCredentialsProvider(provider: CredentialsProvider): Disposable; | |
registerPostCommitCommandsProvider(provider: PostCommitCommandsProvider): Disposable; | |
registerPushErrorHandler(handler: PushErrorHandler): Disposable; | |
registerBranchProtectionProvider(root: Uri, provider: BranchProtectionProvider): Disposable; | |
} | |
export interface GitExtension { | |
readonly enabled: boolean; | |
readonly onDidChangeEnablement: Event<boolean>; | |
/** | |
* Returns a specific API version. | |
* | |
* Throws error if git extension is disabled. You can listen to the | |
* [GitExtension.onDidChangeEnablement](#GitExtension.onDidChangeEnablement) event | |
* to know when the extension becomes enabled/disabled. | |
* | |
* @param version Version number. | |
* @returns API instance | |
*/ | |
getAPI(version: 1): API; | |
} | |
export const enum GitErrorCodes { | |
BadConfigFile = 'BadConfigFile', | |
AuthenticationFailed = 'AuthenticationFailed', | |
NoUserNameConfigured = 'NoUserNameConfigured', | |
NoUserEmailConfigured = 'NoUserEmailConfigured', | |
NoRemoteRepositorySpecified = 'NoRemoteRepositorySpecified', | |
NotAGitRepository = 'NotAGitRepository', | |
NotAtRepositoryRoot = 'NotAtRepositoryRoot', | |
Conflict = 'Conflict', | |
StashConflict = 'StashConflict', | |
UnmergedChanges = 'UnmergedChanges', | |
PushRejected = 'PushRejected', | |
RemoteConnectionError = 'RemoteConnectionError', | |
DirtyWorkTree = 'DirtyWorkTree', | |
CantOpenResource = 'CantOpenResource', | |
GitNotFound = 'GitNotFound', | |
CantCreatePipe = 'CantCreatePipe', | |
PermissionDenied = 'PermissionDenied', | |
CantAccessRemote = 'CantAccessRemote', | |
RepositoryNotFound = 'RepositoryNotFound', | |
RepositoryIsLocked = 'RepositoryIsLocked', | |
BranchNotFullyMerged = 'BranchNotFullyMerged', | |
NoRemoteReference = 'NoRemoteReference', | |
InvalidBranchName = 'InvalidBranchName', | |
BranchAlreadyExists = 'BranchAlreadyExists', | |
NoLocalChanges = 'NoLocalChanges', | |
NoStashFound = 'NoStashFound', | |
LocalChangesOverwritten = 'LocalChangesOverwritten', | |
NoUpstreamBranch = 'NoUpstreamBranch', | |
IsInSubmodule = 'IsInSubmodule', | |
WrongCase = 'WrongCase', | |
CantLockRef = 'CantLockRef', | |
CantRebaseMultipleBranches = 'CantRebaseMultipleBranches', | |
PatchDoesNotApply = 'PatchDoesNotApply', | |
NoPathFound = 'NoPathFound', | |
UnknownPath = 'UnknownPath', | |
EmptyCommitMessage = 'EmptyCommitMessage', | |
BranchFastForwardRejected = 'BranchFastForwardRejected', | |
BranchNotYetBorn = 'BranchNotYetBorn', | |
TagConflict = 'TagConflict' | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
{ | |
"name": "vscode-git-teamcity-remote-run", | |
"displayName": "VSCode git teamcity remote run", | |
"description": "", | |
"version": "0.0.1", | |
"engines": { | |
"vscode": "^1.77.0" | |
}, | |
"categories": [ | |
"Other" | |
], | |
"activationEvents": [], | |
"main": "./out/extension.js", | |
"contributes": { | |
"commands": [ | |
{ | |
"command": "vscode-git-teamcity-remote-run.remote-run", | |
"title": "Remote Run..." | |
} | |
], | |
"menus": { | |
"scm/resourceGroup/context": [ | |
{ | |
"command": "vscode-git-teamcity-remote-run.remote-run", | |
"when": "scmProvider == git && scmResourceGroup == index" | |
} | |
] | |
} | |
}, | |
"scripts": { | |
"vscode:prepublish": "npm run compile", | |
"compile": "tsc -p ./", | |
"watch": "tsc -watch -p ./", | |
"pretest": "npm run compile && npm run lint", | |
"lint": "eslint src --ext ts", | |
"test": "node ./out/test/runTest.js" | |
}, | |
"devDependencies": { | |
"@types/vscode": "^1.77.0", | |
"@types/glob": "^8.1.0", | |
"@types/mocha": "^10.0.1", | |
"@types/node": "16.x", | |
"@typescript-eslint/eslint-plugin": "^5.56.0", | |
"@typescript-eslint/parser": "^5.56.0", | |
"eslint": "^8.36.0", | |
"glob": "^8.1.0", | |
"mocha": "^10.2.0", | |
"typescript": "^4.9.5", | |
"@vscode/test-electron": "^2.3.0" | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment