ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge VS Code 1.31.1 (#4283)

Browse Source
This commit is contained in:
Matt Irvine
2019-03-15 13:09:45 -07:00
committed by GitHub
parent 7d31575149
commit 86bac90001
1716 changed files with 53308 additions and 48375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/vs/platform/localizations/common/localizations.ts
View File

@@ -29,7 +29,7 @@ export interface ILocalizationsService {
_serviceBrand: any;
readonly onDidLanguagesChange: Event<void>;
getLanguageIds(type?: LanguageType): Thenable<string[]>;
getLanguageIds(type?: LanguageType): Promise<string[]>;
}
export function isValidLocalization(localization: ILocalization): boolean {

28
src/vs/platform/localizations/node/localizations.ts
View File

@@ -9,7 +9,7 @@ import { IExtensionManagementService, ILocalExtension, IExtensionIdentifier } fr
import { Disposable } from 'vs/base/common/lifecycle';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { Queue } from 'vs/base/common/async';
import { areSameExtensions, getGalleryExtensionIdFromLocal, getIdFromLocalExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
import { ILogService } from 'vs/platform/log/common/log';
import { isValidLocalization, ILocalizationsService, LanguageType } from 'vs/platform/localizations/common/localizations';
import product from 'vs/platform/node/product';
@@ -42,9 +42,9 @@ export class LocalizationsService extends Disposable implements ILocalizationsSe
readonly onDidLanguagesChange: Event<void> = this._onDidLanguagesChange.event;
constructor(
@IExtensionManagementService private extensionManagementService: IExtensionManagementService,
@IExtensionManagementService private readonly extensionManagementService: IExtensionManagementService,
@IEnvironmentService environmentService: IEnvironmentService,
@ILogService private logService: ILogService
@ILogService private readonly logService: ILogService
) {
super();
this.cache = this._register(new LanguagePacksCache(environmentService, logService));
@@ -55,7 +55,7 @@ export class LocalizationsService extends Disposable implements ILocalizationsSe
this.extensionManagementService.getInstalled().then(installed => this.cache.update(installed));
}
getLanguageIds(type: LanguageType): Thenable<string[]> {
getLanguageIds(type: LanguageType): Promise<string[]> {
if (type === LanguageType.Core) {
return Promise.resolve([...systemLanguages]);
}
@@ -66,7 +66,7 @@ export class LocalizationsService extends Disposable implements ILocalizationsSe
});
}
private onDidInstallExtension(extension: ILocalExtension): void {
private onDidInstallExtension(extension: ILocalExtension | undefined): void {
if (extension && extension.manifest && extension.manifest.contributes && extension.manifest.contributes.localizations && extension.manifest.contributes.localizations.length) {
this.logService.debug('Adding language packs from the extension', extension.identifier.id);
this.update();
@@ -76,7 +76,6 @@ export class LocalizationsService extends Disposable implements ILocalizationsSe
private onDidUninstallExtension(identifier: IExtensionIdentifier): void {
this.cache.getLanguagePacks()
.then(languagePacks => {
identifier = { id: getIdFromLocalExtensionId(identifier.id), uuid: identifier.uuid };
if (Object.keys(languagePacks).some(language => languagePacks[language] && languagePacks[language].extensions.some(e => areSameExtensions(e.extensionIdentifier, identifier)))) {
this.logService.debug('Removing language packs from the extension', identifier.id);
this.update();
@@ -103,14 +102,14 @@ class LanguagePacksCache extends Disposable {
constructor(
@IEnvironmentService environmentService: IEnvironmentService,
@ILogService private logService: ILogService
@ILogService private readonly logService: ILogService
) {
super();
this.languagePacksFilePath = posix.join(environmentService.userDataPath, 'languagepacks.json');
this.languagePacksFileLimiter = new Queue();
}
getLanguagePacks(): Thenable<{ [language: string]: ILanguagePack }> {
getLanguagePacks(): Promise<{ [language: string]: ILanguagePack }> {
// if queue is not empty, fetch from disk
if (this.languagePacksFileLimiter.size) {
return this.withLanguagePacks()
@@ -119,9 +118,9 @@ class LanguagePacksCache extends Disposable {
return Promise.resolve(this.languagePacks);
}
update(extensions: ILocalExtension[]): Thenable<{ [language: string]: ILanguagePack }> {
update(extensions: ILocalExtension[]): Promise<{ [language: string]: ILanguagePack }> {
return this.withLanguagePacks(languagePacks => {
Object.keys(languagePacks).forEach(language => languagePacks[language] = undefined);
Object.keys(languagePacks).forEach(language => delete languagePacks[language]);
this.createLanguagePacksFromExtensions(languagePacks, ...extensions);
}).then(() => this.languagePacks);
}
@@ -136,8 +135,9 @@ class LanguagePacksCache extends Disposable {
}
private createLanguagePacksFromExtension(languagePacks: { [language: string]: ILanguagePack }, extension: ILocalExtension): void {
const extensionIdentifier = { id: getGalleryExtensionIdFromLocal(extension), uuid: extension.identifier.uuid };
for (const localizationContribution of extension.manifest.contributes.localizations) {
const extensionIdentifier = extension.identifier;
const localizations = extension.manifest.contributes && extension.manifest.contributes.localizations ? extension.manifest.contributes.localizations : [];
for (const localizationContribution of localizations) {
if (extension.location.scheme === Schemas.file && isValidLocalization(localizationContribution)) {
let languagePack = languagePacks[localizationContribution.languageId];
if (!languagePack) {
@@ -167,11 +167,11 @@ class LanguagePacksCache extends Disposable {
}
}
private withLanguagePacks<T>(fn: (languagePacks: { [language: string]: ILanguagePack }) => T = () => null): Thenable<T> {
private withLanguagePacks<T>(fn: (languagePacks: { [language: string]: ILanguagePack }) => T | null = () => null): Promise<T> {
return this.languagePacksFileLimiter.queue(() => {
let result: T | null = null;
return pfs.readFile(this.languagePacksFilePath, 'utf8')
.then(null, err => err.code === 'ENOENT' ? Promise.resolve('{}') : Promise.reject(err))
.then(undefined, err => err.code === 'ENOENT' ? Promise.resolve('{}') : Promise.reject(err))
.then<{ [language: string]: ILanguagePack }>(raw => { try { return JSON.parse(raw); } catch (e) { return {}; } })
.then(languagePacks => { result = fn(languagePacks); return languagePacks; })
.then(languagePacks => {

8
src/vs/platform/localizations/node/localizationsIpc.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { IChannel, IServerChannel } from 'vs/base/parts/ipc/node/ipc';
import { Event, buffer } from 'vs/base/common/event';
import { Event } from 'vs/base/common/event';
import { ILocalizationsService, LanguageType } from 'vs/platform/localizations/common/localizations';
export class LocalizationsChannel implements IServerChannel {
@@ -12,7 +12,7 @@ export class LocalizationsChannel implements IServerChannel {
onDidLanguagesChange: Event<void>;
constructor(private service: ILocalizationsService) {
this.onDidLanguagesChange = buffer(service.onDidLanguagesChange, true);
this.onDidLanguagesChange = Event.buffer(service.onDidLanguagesChange, true);
}
listen(_, event: string): Event<any> {
@@ -23,7 +23,7 @@ export class LocalizationsChannel implements IServerChannel {
throw new Error(`Event not found: ${event}`);
}
call(_, command: string, arg?: any): Thenable<any> {
call(_, command: string, arg?: any): Promise<any> {
switch (command) {
case 'getLanguageIds': return this.service.getLanguageIds(arg);
}
@@ -40,7 +40,7 @@ export class LocalizationsChannelClient implements ILocalizationsService {
get onDidLanguagesChange(): Event<void> { return this.channel.listen('onDidLanguagesChange'); }
getLanguageIds(type?: LanguageType): Thenable<string[]> {
getLanguageIds(type?: LanguageType): Promise<string[]> {
return this.channel.call('getLanguageIds', type);
}
}