OCram85/code-server
Archived
1
0
Fork 0
Code Pull Requests 2 Activity

chore(vscode): update to 1.55.2

Browse Source
This commit is contained in:
Akash Satheesan
2021-04-09 11:32:27 +05:30
parent e07ae004b7 801aed9320
commit 8fb96b9967
1102 changed files with 39988 additions and 23544 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
lib/vscode/extensions/github/src/publish.ts
View File

@ -168,7 +168,12 @@ export async function publishRepository(gitAPI: GitAPI, repository?: Repository)
}
const githubRepository = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, cancellable: false, title: 'Publish to GitHub' }, async progress => {
progress.report({ message: `Publishing to GitHub ${isPrivate ? 'private' : 'public'} repository`, increment: 25 });
progress.report({
message: isPrivate
? localize('publishing_private', "Publishing to a private GitHub repository")
: localize('publishing_public', "Publishing to a public GitHub repository"),
increment: 25
});
const res = await octokit.repos.createForAuthenticatedUser({
name: repo!,
@ -177,7 +182,7 @@ export async function publishRepository(gitAPI: GitAPI, repository?: Repository)
const createdGithubRepository = res.data;
progress.report({ message: 'Creating first commit', increment: 25 });
progress.report({ message: localize('publishing_firstcommit', "Creating first commit"), increment: 25 });
if (!repository) {
repository = await gitAPI.init(folder) || undefined;
@ -189,7 +194,8 @@ export async function publishRepository(gitAPI: GitAPI, repository?: Repository)
await repository.commit('first commit', { all: true });
}
progress.report({ message: 'Uploading files', increment: 25 });
progress.report({ message: localize('publishing_uploading', "Uploading files"), increment: 25 });
const branch = await repository.getBranch('HEAD');
await repository.addRemote('origin', createdGithubRepository.clone_url);
await repository.push('origin', branch.name, true);
@ -201,9 +207,9 @@ export async function publishRepository(gitAPI: GitAPI, repository?: Repository)
return;
}
const openInGitHub = 'Open In GitHub';
vscode.window.showInformationMessage(`Successfully published the '${owner}/${repo}' repository on GitHub.`, openInGitHub).then(action => {
if (action === openInGitHub) {
const openOnGitHub = localize('openingithub', "Open on GitHub");
vscode.window.showInformationMessage(localize('publishing_done', "Successfully published the '{0}' repository to GitHub.", `${owner}/${repo}`), openOnGitHub).then(action => {
if (action === openOnGitHub) {
vscode.commands.executeCommand('vscode.open', vscode.Uri.parse(githubRepository.html_url));
}
});

87
lib/vscode/extensions/github/src/pushErrorHandler.ts
View File

@ -3,37 +3,95 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { PushErrorHandler, GitErrorCodes, Repository, Remote } from './typings/git';
import { window, ProgressLocation, commands, Uri } from 'vscode';
import { commands, env, ProgressLocation, UIKind, Uri, window } from 'vscode';
import * as nls from 'vscode-nls';
import { getOctokit } from './auth';
import { GitErrorCodes, PushErrorHandler, Remote, Repository } from './typings/git';
const localize = nls.loadMessageBundle();
type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;
export function isInCodespaces(): boolean {
return env.remoteName === 'codespaces';
}
async function handlePushError(repository: Repository, remote: Remote, refspec: string, owner: string, repo: string): Promise<void> {
const inCodespaces = isInCodespaces();
let codespace: string | undefined;
if (inCodespaces) {
if (env.uiKind === UIKind.Web) {
// TODO@eamodio Find a better way to get the codespace id
// HACK to get the codespace id
try {
const codespaceUrl = (await env.asExternalUri(Uri.parse(`${env.uriScheme}://codespace/`))).authority;
if (codespaceUrl.endsWith('.github.dev')) {
codespace = codespaceUrl.slice(0, -11);
} else {
[codespace] = codespaceUrl.split('.');
}
} catch { }
} else {
// Call into the codespaces extension to get the codespace id
const info = await commands.executeCommand<{ name: string } | undefined>('github.codespaces.getCurrentCodespace');
codespace = info?.name;
}
if (!codespace) {
const ok = localize('ok', "OK");
await window.showErrorMessage(localize('fork unable', "You don't have permissions to push to '{0}/{1}' on GitHub.", owner, repo), ok);
return;
}
}
const yes = localize('create a fork', "Create Fork");
const no = localize('no', "No");
const answer = await window.showInformationMessage(localize('fork', "You don't have permissions to push to '{0}/{1}' on GitHub. Would you like to create a fork and push to it instead?", owner, repo), yes, no);
if (answer === no) {
return;
}
const match = /^([^:]*):([^:]*)$/.exec(refspec);
const localName = match ? match[1] : refspec;
const remoteName = match ? match[2] : refspec;
let remoteName = match ? match[2] : refspec;
const [octokit, ghRepository] = await window.withProgress({ location: ProgressLocation.Notification, cancellable: false, title: localize('create fork', 'Create GitHub fork') }, async progress => {
progress.report({ message: localize('forking', "Forking '{0}/{1}'...", owner, repo), increment: 33 });
const octokit = await getOctokit();
// Issue: what if the repo already exists?
const res = await octokit.repos.createFork({ owner, repo });
const ghRepository = res.data;
type CreateForkResponseData = Awaited<ReturnType<typeof octokit.repos.createFork>>['data'];
progress.report({ message: localize('pushing', "Pushing changes..."), increment: 33 });
// Issue: what if the repo already exists?
let ghRepository: CreateForkResponseData;
try {
if (inCodespaces) {
const userResp = await octokit.users.getAuthenticated();
const user = userResp.data.login;
const resp = await octokit.request<{ repository: CreateForkResponseData, ref: string }>({ method: 'POST', url: `/vscs_internal/user/${user}/codespaces/${codespace}/fork_repo` });
ghRepository = resp.data.repository;
if (resp.data.ref) {
let ref = resp.data.ref;
if (ref.startsWith('refs/heads/')) {
ref = ref.substr(11);
}
remoteName = ref;
}
} else {
const resp = await octokit.repos.createFork({ owner, repo });
ghRepository = resp.data;
}
} catch (ex) {
console.error(ex);
throw ex;
}
progress.report({ message: localize('forking_pushing', "Pushing changes..."), increment: 33 });
// Issue: what if there's already an `upstream` repo?
await repository.renameRemote(remote.name, 'upstream');
@ -55,11 +113,11 @@ async function handlePushError(repository: Repository, remote: Remote, refspec:
// yield
(async () => {
const openInGitHub = localize('openingithub', "Open In GitHub");
const openOnGitHub = localize('openingithub', "Open on GitHub");
const createPR = localize('createpr', "Create PR");
const action = await window.showInformationMessage(localize('done', "The fork '{0}' was successfully created on GitHub.", ghRepository.full_name), openInGitHub, createPR);
const action = await window.showInformationMessage(localize('forking_done', "The fork '{0}' was successfully created on GitHub.", ghRepository.full_name), openOnGitHub, createPR);
if (action === openInGitHub) {
if (action === openOnGitHub) {
await commands.executeCommand('vscode.open', Uri.parse(ghRepository.html_url));
} else if (action === createPR) {
const pr = await window.withProgress({ location: ProgressLocation.Notification, cancellable: false, title: localize('createghpr', "Creating GitHub Pull Request...") }, async _ => {
@ -103,12 +161,13 @@ export class GithubPushErrorHandler implements PushErrorHandler {
return false;
}
if (!remote.pushUrl) {
const remoteUrl = remote.pushUrl || (isInCodespaces() ? remote.fetchUrl : undefined);
if (!remoteUrl) {
return false;
}
const match = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\.git/i.exec(remote.pushUrl)
|| /^git@github\.com:([^/]+)\/([^/]+)\.git/i.exec(remote.pushUrl);
const match = /^https:\/\/github\.com\/([^/]+)\/([^/]+)(?:\.git)?/i.exec(remoteUrl)
|| /^git@github\.com:([^/]+)\/([^/]+)(?:\.git)?/i.exec(remoteUrl);
if (!match) {
return false;

2
lib/vscode/extensions/github/src/remoteSourceProvider.ts
View File

@ -76,7 +76,7 @@ export class GithubRemoteSourceProvider implements RemoteSourceProvider {
return [];
}
const raw = await octokit.search.repos({ q: query, sort: 'updated' });
const raw = await octokit.search.repos({ q: query, sort: 'stars' });
return raw.data.items.map(asRemoteSource);
}