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

Merge from vscode 05fc61ffb1aee9fd19173c32113daed079f9b7bd (#5074)

Browse Source 
* Merge from vscode 05fc61ffb1aee9fd19173c32113daed079f9b7bd

* fix tests
This commit is contained in:
Anthony Dresser
2019-04-16 22:11:30 -07:00
committed by GitHub
parent 2f8519cb6b
commit 8956b591f7
217 changed files with 5120 additions and 3926 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/vs/workbench/services/configuration/browser/configuration.ts
View File

@@ -133,7 +133,7 @@ export class UserConfiguration extends Disposable {
async reload(): Promise<ConfigurationModel> {
try {
const content = await this.configurationFileService.resolveContent(this.configurationResource);
const content = await this.configurationFileService.readFile(this.configurationResource);
this.parser.parseContent(content);
return this.parser.configurationModel;
} catch (e) {
@@ -379,7 +379,7 @@ class FileServiceBasedWorkspaceConfiguration extends Disposable implements IWork
}
let contents = '';
try {
contents = await this.configurationFileService.resolveContent(this._workspaceIdentifier.configPath);
contents = await this.configurationFileService.readFile(this._workspaceIdentifier.configPath);
} catch (error) {
const exists = await this.configurationFileService.exists(this._workspaceIdentifier.configPath);
if (exists) {
@@ -547,7 +547,7 @@ class FileServiceBasedFolderConfiguration extends Disposable implements IFolderC
async loadConfiguration(): Promise<ConfigurationModel> {
const configurationContents = await Promise.all(this.configurationResources.map(async resource => {
try {
return await this.configurationFileService.resolveContent(resource);
return await this.configurationFileService.readFile(resource);
} catch (error) {
const exists = await this.configurationFileService.exists(resource);
if (exists) {

54
src/vs/workbench/services/configuration/browser/configurationService.ts
View File

@@ -4,14 +4,13 @@
*--------------------------------------------------------------------------------------------*/
import { URI } from 'vs/base/common/uri';
import * as assert from 'vs/base/common/assert';
import { Event, Emitter } from 'vs/base/common/event';
import { ResourceMap } from 'vs/base/common/map';
import { equals, deepClone } from 'vs/base/common/objects';
import { Disposable } from 'vs/base/common/lifecycle';
import { Queue, Barrier } from 'vs/base/common/async';
import { IJSONContributionRegistry, Extensions as JSONExtensions } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
import { IWorkspaceContextService, Workspace, WorkbenchState, IWorkspaceFolder, toWorkspaceFolders, IWorkspaceFoldersChangeEvent, WorkspaceFolder } from 'vs/platform/workspace/common/workspace';
import { IWorkspaceContextService, Workspace, WorkbenchState, IWorkspaceFolder, toWorkspaceFolders, IWorkspaceFoldersChangeEvent, WorkspaceFolder, toWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
import { isLinux } from 'vs/base/common/platform';
import { ConfigurationChangeEvent, ConfigurationModel, DefaultConfigurationModel } from 'vs/platform/configuration/common/configurationModels';
import { IConfigurationChangeEvent, ConfigurationTarget, IConfigurationOverrides, keyFromOverrideIdentifier, isConfigurationOverrides, IConfigurationData, IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -61,6 +60,9 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
private configurationEditingService: ConfigurationEditingService;
private jsonEditingService: JSONEditingService;
private cyclicDependencyReady: Function;
private cyclicDependency = new Promise<void>(resolve => this.cyclicDependencyReady = resolve);
constructor(
{ userSettingsResource, remoteAuthority, configurationCache }: { userSettingsResource?: URI, remoteAuthority?: string, configurationCache: IConfigurationCache },
private readonly configurationFileService: IConfigurationFileService,
@@ -131,8 +133,9 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
}
public updateFolders(foldersToAdd: IWorkspaceFolderCreationData[], foldersToRemove: URI[], index?: number): Promise<void> {
assert.ok(this.jsonEditingService, 'Workbench is not initialized yet');
return Promise.resolve(this.workspaceEditingQueue.queue(() => this.doUpdateFolders(foldersToAdd, foldersToRemove, index)));
return this.cyclicDependency.then(() => {
return this.workspaceEditingQueue.queue(() => this.doUpdateFolders(foldersToAdd, foldersToRemove, index));
});
}
public isInsideWorkspace(resource: URI): boolean {
@@ -178,8 +181,9 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
if (foldersToAdd.length) {
// Recompute current workspace folders if we have folders to add
const workspaceConfigFolder = dirname(this.getWorkspace().configuration!);
currentWorkspaceFolders = toWorkspaceFolders(newStoredFolders, workspaceConfigFolder);
const workspaceConfigPath = this.getWorkspace().configuration!;
const workspaceConfigFolder = dirname(workspaceConfigPath);
currentWorkspaceFolders = toWorkspaceFolders(newStoredFolders, workspaceConfigPath);
const currentWorkspaceFolderUris = currentWorkspaceFolders.map(folder => folder.uri);
const storedFoldersToAdd: IStoredWorkspaceFolder[] = [];
@@ -214,8 +218,10 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
}
private setFolders(folders: IStoredWorkspaceFolder[]): Promise<void> {
return this.workspaceConfiguration.setFolders(folders, this.jsonEditingService)
.then(() => this.onWorkspaceConfigurationChanged());
return this.cyclicDependency.then(() => {
return this.workspaceConfiguration.setFolders(folders, this.jsonEditingService)
.then(() => this.onWorkspaceConfigurationChanged());
});
}
private contains(resources: URI[], toCheck: URI): boolean {
@@ -250,11 +256,12 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
updateValue(key: string, value: any, overrides: IConfigurationOverrides, target: ConfigurationTarget): Promise<void>;
updateValue(key: string, value: any, overrides: IConfigurationOverrides, target: ConfigurationTarget, donotNotifyError: boolean): Promise<void>;
updateValue(key: string, value: any, arg3?: any, arg4?: any, donotNotifyError?: any): Promise<void> {
assert.ok(this.configurationEditingService, 'Workbench is not initialized yet');
const overrides = isConfigurationOverrides(arg3) ? arg3 : undefined;
const target = this.deriveConfigurationTarget(key, value, overrides, overrides ? arg4 : arg3);
return target ? this.writeConfigurationValue(key, value, target, overrides, donotNotifyError)
: Promise.resolve();
return this.cyclicDependency.then(() => {
const overrides = isConfigurationOverrides(arg3) ? arg3 : undefined;
const target = this.deriveConfigurationTarget(key, value, overrides, overrides ? arg4 : arg3);
return target ? this.writeConfigurationValue(key, value, target, overrides, donotNotifyError)
: Promise.resolve();
});
}
reloadConfiguration(folder?: IWorkspaceFolder, key?: string): Promise<void> {
@@ -299,6 +306,12 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
acquireInstantiationService(instantiationService: IInstantiationService): void {
this.configurationEditingService = instantiationService.createInstance(ConfigurationEditingService);
this.jsonEditingService = instantiationService.createInstance(JSONEditingService);
if (this.cyclicDependencyReady) {
this.cyclicDependencyReady();
} else {
this.cyclicDependency = Promise.resolve(undefined);
}
}
private createWorkspace(arg: IWorkspaceInitializationPayload): Promise<Workspace> {
@@ -317,7 +330,7 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
return this.workspaceConfiguration.load({ id: workspaceIdentifier.id, configPath: workspaceIdentifier.configPath })
.then(() => {
const workspaceConfigPath = workspaceIdentifier.configPath;
const workspaceFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), dirname(workspaceConfigPath));
const workspaceFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), workspaceConfigPath);
const workspaceId = workspaceIdentifier.id;
const workspace = new Workspace(workspaceId, workspaceFolders, workspaceConfigPath);
if (this.workspaceConfiguration.loaded) {
@@ -328,16 +341,7 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
}
private createSingleFolderWorkspace(singleFolder: ISingleFolderWorkspaceInitializationPayload): Promise<Workspace> {
const folder = singleFolder.folder;
let configuredFolders: IStoredWorkspaceFolder[];
if (folder.scheme === 'file') {
configuredFolders = [{ path: folder.fsPath }];
} else {
configuredFolders = [{ uri: folder.toString() }];
}
const workspace = new Workspace(singleFolder.id, toWorkspaceFolders(configuredFolders));
const workspace = new Workspace(singleFolder.id, [toWorkspaceFolder(singleFolder.folder)]);
this.releaseWorkspaceBarrier(); // Release barrier as workspace is complete because it is single folder.
return Promise.resolve(workspace);
}
@@ -546,7 +550,7 @@ export class WorkspaceService extends Disposable implements IConfigurationServic
private onWorkspaceConfigurationChanged(): Promise<void> {
if (this.workspace && this.workspace.configuration && this._configuration) {
const workspaceConfigurationChangeEvent = this._configuration.compareAndUpdateWorkspaceConfiguration(this.workspaceConfiguration.getConfiguration());
let configuredFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), dirname(this.workspace.configuration));
let configuredFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), this.workspace.configuration);
const changes = this.compareFolders(this.workspace.folders, configuredFolders);
if (changes.added.length || changes.removed.length || changes.changed.length) {
this.workspace.folders = configuredFolders;

6
src/vs/workbench/services/configuration/common/configuration.ts
View File

@@ -49,7 +49,7 @@ export interface IConfigurationFileService {
whenProviderRegistered(scheme: string): Promise<void>;
watch(resource: URI): IDisposable;
exists(resource: URI): Promise<boolean>;
resolveContent(resource: URI): Promise<string>;
readFile(resource: URI): Promise<string>;
}
export class ConfigurationFileService implements IConfigurationFileService {
@@ -82,8 +82,8 @@ export class ConfigurationFileService implements IConfigurationFileService {
return this.fileService.exists(resource);
}
resolveContent(resource: URI): Promise<string> {
return this.fileService.resolveContent(resource, { encoding: 'utf8' }).then(content => content.value);
readFile(resource: URI): Promise<string> {
return this.fileService.readFile(resource).then(content => content.value.toString());
}
}

4
src/vs/workbench/services/configuration/node/configurationFileService.ts
View File

@@ -51,9 +51,9 @@ export class ConfigurationFileService extends Disposable implements IConfigurati
return this._fileServiceBasedConfigurationFileService ? this._fileServiceBasedConfigurationFileService.exists(resource) : pfs.exists(resource.fsPath);
}
async resolveContent(resource: URI): Promise<string> {
async readFile(resource: URI): Promise<string> {
if (this._fileServiceBasedConfigurationFileService) {
return this._fileServiceBasedConfigurationFileService.resolveContent(resource);
return this._fileServiceBasedConfigurationFileService.readFile(resource);
} else {
const contents = await pfs.readFile(resource.fsPath);
return contents.toString();

15
src/vs/workbench/services/configuration/test/electron-browser/configurationEditingService.test.ts
View File

@@ -14,11 +14,10 @@ import { ParsedArgs, IEnvironmentService } from 'vs/platform/environment/common/
import { parseArgs } from 'vs/platform/environment/node/argv';
import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
import { EnvironmentService } from 'vs/platform/environment/node/environmentService';
import { TestTextFileService, TestTextResourceConfigurationService, workbenchInstantiationService, TestEnvironmentService } from 'vs/workbench/test/workbenchTestServices';
import { TestTextFileService, workbenchInstantiationService } from 'vs/workbench/test/workbenchTestServices';
import * as uuid from 'vs/base/common/uuid';
import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry';
import { WorkspaceService } from 'vs/workbench/services/configuration/browser/configurationService';
import { LegacyFileService } from 'vs/workbench/services/files/node/fileService';
import { ConfigurationEditingService, ConfigurationEditingError, ConfigurationEditingErrorCode, EditableConfigurationTarget } from 'vs/workbench/services/configuration/common/configurationEditingService';
import { WORKSPACE_STANDALONE_CONFIGURATIONS } from 'vs/workbench/services/configuration/common/configuration';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -34,10 +33,10 @@ import { URI } from 'vs/base/common/uri';
import { createHash } from 'crypto';
import { RemoteAgentService } from 'vs/workbench/services/remote/electron-browser/remoteAgentServiceImpl';
import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
import { FileService2 } from 'vs/workbench/services/files2/common/fileService2';
import { FileService } from 'vs/workbench/services/files/common/fileService';
import { NullLogService } from 'vs/platform/log/common/log';
import { Schemas } from 'vs/base/common/network';
import { DiskFileSystemProvider } from 'vs/workbench/services/files2/node/diskFileSystemProvider';
import { DiskFileSystemProvider } from 'vs/workbench/services/files/node/diskFileSystemProvider';
import { IFileService } from 'vs/platform/files/common/files';
import { ConfigurationCache } from 'vs/workbench/services/configuration/node/configurationCache';
import { ConfigurationFileService } from 'vs/workbench/services/configuration/node/configurationFileService';
@@ -111,14 +110,8 @@ suite('ConfigurationEditingService', () => {
instantiationService.stub(IWorkspaceContextService, workspaceService);
return workspaceService.initialize(noWorkspace ? { id: '' } : { folder: URI.file(workspaceDir), id: createHash('md5').update(URI.file(workspaceDir).toString()).digest('hex') }).then(() => {
instantiationService.stub(IConfigurationService, workspaceService);
const fileService = new FileService2(new NullLogService());
const fileService = new FileService(new NullLogService());
fileService.registerProvider(Schemas.file, new DiskFileSystemProvider(new NullLogService()));
fileService.setLegacyService(new LegacyFileService(
fileService,
workspaceService,
TestEnvironmentService,
new TestTextResourceConfigurationService(),
));
instantiationService.stub(IFileService, fileService);
instantiationService.stub(ITextFileService, instantiationService.createInstance(TestTextFileService));
instantiationService.stub(ITextModelService, <ITextModelService>instantiationService.createInstance(TextModelResolverService));

7
src/vs/workbench/services/configuration/test/electron-browser/configurationService.test.ts
View File

@@ -22,8 +22,7 @@ import { ConfigurationEditingErrorCode } from 'vs/workbench/services/configurati
import { IFileService } from 'vs/platform/files/common/files';
import { IWorkspaceContextService, WorkbenchState, IWorkspaceFoldersChangeEvent } from 'vs/platform/workspace/common/workspace';
import { ConfigurationTarget, IConfigurationService, IConfigurationChangeEvent } from 'vs/platform/configuration/common/configuration';
import { workbenchInstantiationService, TestTextResourceConfigurationService, TestTextFileService, TestEnvironmentService } from 'vs/workbench/test/workbenchTestServices';
import { LegacyFileService } from 'vs/workbench/services/files/node/fileService';
import { workbenchInstantiationService, TestTextFileService } from 'vs/workbench/test/workbenchTestServices';
import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
import { ITextModelService } from 'vs/editor/common/services/resolverService';
@@ -38,9 +37,9 @@ import { IWindowConfiguration } from 'vs/platform/windows/common/windows';
import { RemoteAgentService } from 'vs/workbench/services/remote/electron-browser/remoteAgentServiceImpl';
import { RemoteAuthorityResolverService } from 'vs/platform/remote/electron-browser/remoteAuthorityResolverService';
import { IRemoteAgentService } from 'vs/workbench/services/remote/common/remoteAgentService';
import { FileService2 } from 'vs/workbench/services/files2/common/fileService2';
import { FileService } from 'vs/workbench/services/files/common/fileService';
import { NullLogService } from 'vs/platform/log/common/log';
import { DiskFileSystemProvider } from 'vs/workbench/services/files2/node/diskFileSystemProvider';
import { DiskFileSystemProvider } from 'vs/workbench/services/files/node/diskFileSystemProvider';
import { ConfigurationCache } from 'vs/workbench/services/configuration/node/configurationCache';
import { ConfigurationFileService } from 'vs/workbench/services/configuration/node/configurationFileService';