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

Refresh master with initial release/0.24 snapshot (#332)

Browse Source 
* Initial port of release/0.24 source code

* Fix additional headers

* Fix a typo in launch.json
This commit is contained in:
Karl Burtram
2017-12-15 15:38:57 -08:00
committed by GitHub
parent 271b3a0b82
commit 6ad0df0e3e
7118 changed files with 107999 additions and 56466 deletions
Download Patch File Download Diff File Expand all files Collapse all files

802
src/vs/workbench/services/configuration/node/configuration.ts
View File

@@ -2,38 +2,28 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import URI from 'vs/base/common/uri';
import * as paths from 'vs/base/common/paths';
import { TPromise } from 'vs/base/common/winjs.base';
import Event, { Emitter } from 'vs/base/common/event';
import { StrictResourceMap } from 'vs/base/common/map';
import { equals, coalesce } from 'vs/base/common/arrays';
import * as objects from 'vs/base/common/objects';
import { readFile } from 'vs/base/node/pfs';
import * as errors from 'vs/base/common/errors';
import * as collections from 'vs/base/common/collections';
import { Disposable, toDisposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
import { RunOnceScheduler } from 'vs/base/common/async';
import { readFile, stat } from 'vs/base/node/pfs';
import { IJSONContributionRegistry, Extensions as JSONExtensions } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
import * as extfs from 'vs/base/node/extfs';
import { IWorkspaceContextService, IWorkspace, Workspace, ILegacyWorkspace, LegacyWorkspace } from 'vs/platform/workspace/common/workspace';
import { FileChangeType, FileChangesEvent } from 'vs/platform/files/common/files';
import { isLinux } from 'vs/base/common/platform';
import { ConfigWatcher } from 'vs/base/node/config';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { CustomConfigurationModel } from 'vs/platform/configuration/common/model';
import { WorkspaceConfigurationModel, ScopedConfigurationModel, FolderConfigurationModel, FolderSettingsModel } from 'vs/workbench/services/configuration/common/configurationModels';
import { IConfigurationServiceEvent, ConfigurationSource, IConfigurationKeys, IConfigurationValue, ConfigurationModel, IConfigurationOverrides, Configuration as BaseConfiguration, IConfigurationValues, IConfigurationData } from 'vs/platform/configuration/common/configuration';
import { IWorkspaceConfigurationService, WORKSPACE_CONFIG_FOLDER_DEFAULT_NAME, WORKSPACE_STANDALONE_CONFIGURATIONS, WORKSPACE_CONFIG_DEFAULT_PATH } from 'vs/workbench/services/configuration/common/configuration';
import { ConfigurationService as GlobalConfigurationService } from 'vs/platform/configuration/node/configurationService';
import * as nls from 'vs/nls';
import { Registry } from 'vs/platform/registry/common/platform';
import { ExtensionsRegistry, ExtensionMessageCollector } from 'vs/platform/extensions/common/extensionsRegistry';
import { IConfigurationNode, IConfigurationRegistry, Extensions, editorConfigurationSchemaId, IDefaultConfigurationExtension, validateProperty, ConfigurationScope, schemaId } from 'vs/platform/configuration/common/configurationRegistry';
import { createHash } from 'crypto';
import { getWorkspaceLabel, IWorkspacesService, IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, IStoredWorkspaceFolder } from 'vs/platform/workspaces/common/workspaces';
import { CustomConfigurationModel, ConfigurationModel } from 'vs/platform/configuration/common/configurationModels';
import { WorkspaceConfigurationModel, ScopedConfigurationModel, FolderConfigurationModel, FolderSettingsModel, WorkspaceSettingsModel } from 'vs/workbench/services/configuration/common/configurationModels';
import { WORKSPACE_STANDALONE_CONFIGURATIONS, WORKSPACE_CONFIG_DEFAULT_PATH, TASKS_CONFIGURATION_KEY, LAUNCH_CONFIGURATION_KEY } from 'vs/workbench/services/configuration/common/configuration';
import { ConfigurationScope } from 'vs/platform/configuration/common/configurationRegistry';
import { IStoredWorkspace, IStoredWorkspaceFolder } from 'vs/platform/workspaces/common/workspaces';
import * as extfs from 'vs/base/node/extfs';
import { JSONEditingService } from 'vs/workbench/services/configuration/node/jsonEditingService';
// node.hs helper functions
interface IStat {
resource: URI;
@@ -46,602 +36,108 @@ interface IContent {
value: string;
}
interface IWorkspaceConfiguration<T> {
workspace: T;
consolidated: any;
function resolveContents(resources: URI[]): TPromise<IContent[]> {
const contents: IContent[] = [];
return TPromise.join(resources.map(resource => {
return resolveContent(resource).then(content => {
contents.push(content);
});
})).then(() => contents);
}
type IWorkspaceFoldersConfiguration = { [rootFolder: string]: { folders: string[]; } };
const configurationRegistry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);
// BEGIN VSCode extension point `configuration`
const configurationExtPoint = ExtensionsRegistry.registerExtensionPoint<IConfigurationNode>('configuration', [], {
description: nls.localize('vscode.extension.contributes.configuration', 'Contributes configuration settings.'),
type: 'object',
defaultSnippets: [{ body: { title: '', properties: {} } }],
properties: {
title: {
description: nls.localize('vscode.extension.contributes.configuration.title', 'A summary of the settings. This label will be used in the settings file as separating comment.'),
type: 'string'
},
properties: {
description: nls.localize('vscode.extension.contributes.configuration.properties', 'Description of the configuration properties.'),
type: 'object',
additionalProperties: {
anyOf: [
{ $ref: 'http://json-schema.org/draft-04/schema#' },
{
type: 'object',
properties: {
isExecutable: {
type: 'boolean'
},
scope: {
type: 'string',
enum: ['window', 'resource'],
default: 'window',
enumDescriptions: [
nls.localize('scope.window.description', "Window specific configuration, which can be configured in the User or Workspace settings."),
nls.localize('scope.resource.description', "Resource specific configuration, which can be configured in the User, Workspace or Folder settings.")
],
description: nls.localize('scope.description', "Scope in which the configuration is applicable. Available scopes are `window` and `resource`.")
}
}
}
]
}
}
}
});
configurationExtPoint.setHandler(extensions => {
const configurations: IConfigurationNode[] = [];
for (let i = 0; i < extensions.length; i++) {
const configuration = <IConfigurationNode>objects.clone(extensions[i].value);
const collector = extensions[i].collector;
if (configuration.type && configuration.type !== 'object') {
collector.warn(nls.localize('invalid.type', "if set, 'configuration.type' must be set to 'object"));
} else {
configuration.type = 'object';
}
if (configuration.title && (typeof configuration.title !== 'string')) {
collector.error(nls.localize('invalid.title', "'configuration.title' must be a string"));
}
validateProperties(configuration, collector);
configuration.id = extensions[i].description.id;
configurations.push(configuration);
}
configurationRegistry.registerConfigurations(configurations, false);
});
// END VSCode extension point `configuration`
// BEGIN VSCode extension point `configurationDefaults`
const defaultConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint<IConfigurationNode>('configurationDefaults', [], {
description: nls.localize('vscode.extension.contributes.defaultConfiguration', 'Contributes default editor configuration settings by language.'),
type: 'object',
defaultSnippets: [{ body: {} }],
patternProperties: {
'\\[.*\\]$': {
type: 'object',
default: {},
$ref: editorConfigurationSchemaId,
}
}
});
defaultConfigurationExtPoint.setHandler(extensions => {
const defaultConfigurations: IDefaultConfigurationExtension[] = extensions.map(extension => {
const id = extension.description.id;
const name = extension.description.name;
const defaults = objects.clone(extension.value);
return <IDefaultConfigurationExtension>{
id, name, defaults
};
});
configurationRegistry.registerDefaultConfigurations(defaultConfigurations);
});
// END VSCode extension point `configurationDefaults`
function validateProperties(configuration: IConfigurationNode, collector: ExtensionMessageCollector): void {
let properties = configuration.properties;
if (properties) {
if (typeof properties !== 'object') {
collector.error(nls.localize('invalid.properties', "'configuration.properties' must be an object"));
configuration.properties = {};
}
for (let key in properties) {
const message = validateProperty(key);
const propertyConfiguration = configuration.properties[key];
propertyConfiguration.scope = propertyConfiguration.scope && propertyConfiguration.scope.toString() === 'resource' ? ConfigurationScope.RESOURCE : ConfigurationScope.WINDOW;
if (message) {
collector.warn(message);
delete properties[key];
}
}
}
let subNodes = configuration.allOf;
if (subNodes) {
for (let node of subNodes) {
validateProperties(node, collector);
}
}
function resolveContent(resource: URI): TPromise<IContent> {
return readFile(resource.fsPath).then(contents => ({ resource, value: contents.toString() }));
}
export class WorkspaceService extends Disposable implements IWorkspaceConfigurationService, IWorkspaceContextService {
public _serviceBrand: any;
protected workspace: Workspace = null;
protected legacyWorkspace: LegacyWorkspace = null;
protected _configuration: Configuration<any>;
protected readonly _onDidUpdateConfiguration: Emitter<IConfigurationServiceEvent> = this._register(new Emitter<IConfigurationServiceEvent>());
public readonly onDidUpdateConfiguration: Event<IConfigurationServiceEvent> = this._onDidUpdateConfiguration.event;
protected readonly _onDidChangeWorkspaceRoots: Emitter<void> = this._register(new Emitter<void>());
public readonly onDidChangeWorkspaceRoots: Event<void> = this._onDidChangeWorkspaceRoots.event;
protected readonly _onDidChangeWorkspaceName: Emitter<void> = this._register(new Emitter<void>());
public readonly onDidChangeWorkspaceName: Event<void> = this._onDidChangeWorkspaceName.event;
constructor() {
super();
this._configuration = new Configuration(new BaseConfiguration(new ConfigurationModel<any>(), new ConfigurationModel<any>()), new ConfigurationModel<any>(), new StrictResourceMap<FolderConfigurationModel<any>>(), this.workspace);
}
public getLegacyWorkspace(): ILegacyWorkspace {
return this.legacyWorkspace;
}
public getWorkspace(): IWorkspace {
return this.workspace;
}
public hasWorkspace(): boolean {
return !!this.workspace;
}
public hasFolderWorkspace(): boolean {
return this.workspace && !this.workspace.configuration;
}
public hasMultiFolderWorkspace(): boolean {
return this.workspace && !!this.workspace.configuration;
}
public getRoot(resource: URI): URI {
return this.workspace ? this.workspace.getRoot(resource) : null;
}
private get workspaceUri(): URI {
return this.workspace ? this.workspace.roots[0] : null;
}
public isInsideWorkspace(resource: URI): boolean {
return !!this.getRoot(resource);
}
public toResource(workspaceRelativePath: string): URI {
return this.workspace ? this.legacyWorkspace.toResource(workspaceRelativePath) : null;
}
public initialize(trigger: boolean = true): TPromise<any> {
this.resetCaches();
return this.updateConfiguration()
.then(() => {
if (trigger) {
this.triggerConfigurationChange();
function resolveStat(resource: URI): TPromise<IStat> {
return new TPromise<IStat>((c, e) => {
extfs.readdir(resource.fsPath, (error, children) => {
if (error) {
if ((<any>error).code === 'ENOTDIR') {
c({ resource });
} else {
e(error);
}
});
}
public reloadConfiguration(section?: string): TPromise<any> {
return TPromise.as(this.getConfiguration(section));
}
public getConfigurationData<T>(): IConfigurationData<T> {
return this._configuration.toData();
}
public getConfiguration<C>(section?: string, overrides?: IConfigurationOverrides): C {
return this._configuration.getValue<C>(section, overrides);
}
public lookup<C>(key: string, overrides?: IConfigurationOverrides): IConfigurationValue<C> {
return this._configuration.lookup<C>(key, overrides);
}
public keys(overrides?: IConfigurationOverrides): IConfigurationKeys {
return this._configuration.keys(overrides);
}
public values<V>(): IConfigurationValues {
return this._configuration.values();
}
public getUnsupportedWorkspaceKeys(): string[] {
return [];
}
public isInWorkspaceContext(): boolean {
return false;
}
protected triggerConfigurationChange(): void {
this._onDidUpdateConfiguration.fire({ source: ConfigurationSource.Workspace, sourceConfig: void 0 });
}
public handleWorkspaceFileEvents(event: FileChangesEvent): void {
// implemented by sub classes
}
protected resetCaches(): void {
// implemented by sub classes
}
protected updateConfiguration(): TPromise<boolean> {
// implemented by sub classes
return TPromise.as(false);
}
}
export class EmptyWorkspaceServiceImpl extends WorkspaceService {
private baseConfigurationService: GlobalConfigurationService<any>;
constructor(environmentService: IEnvironmentService) {
super();
this.baseConfigurationService = this._register(new GlobalConfigurationService(environmentService));
this._register(this.baseConfigurationService.onDidUpdateConfiguration(e => this.onBaseConfigurationChanged(e)));
this.resetCaches();
}
public reloadConfiguration(section?: string): TPromise<any> {
const current = this._configuration;
return this.baseConfigurationService.reloadConfiguration()
.then(() => this.initialize(false)) // Reinitialize to ensure we are hitting the disk
.then(() => {
// Check and trigger
if (!this._configuration.equals(current)) {
this.triggerConfigurationChange();
}
return super.reloadConfiguration(section);
});
}
private onBaseConfigurationChanged({ source, sourceConfig }: IConfigurationServiceEvent): void {
if (this._configuration.updateBaseConfiguration(<any>this.baseConfigurationService.configuration())) {
this._onDidUpdateConfiguration.fire({ source, sourceConfig });
}
}
protected resetCaches(): void {
this._configuration = new Configuration(<any>this.baseConfigurationService.configuration(), new ConfigurationModel<any>(), new StrictResourceMap<FolderConfigurationModel<any>>(), null);
}
protected triggerConfigurationChange(): void {
this._onDidUpdateConfiguration.fire({ source: ConfigurationSource.User, sourceConfig: this._configuration.user.contents });
}
}
export class WorkspaceServiceImpl extends WorkspaceService {
public _serviceBrand: any;
private workspaceConfigPath: URI;
private folderPath: URI;
private baseConfigurationService: GlobalConfigurationService<any>;
private workspaceConfiguration: WorkspaceConfiguration;
private cachedFolderConfigs: StrictResourceMap<FolderConfiguration<any>>;
constructor(private workspaceIdentifier: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier, private environmentService: IEnvironmentService, private workspacesService: IWorkspacesService, private workspaceSettingsRootFolder: string = WORKSPACE_CONFIG_FOLDER_DEFAULT_NAME) {
super();
if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {
this.folderPath = URI.file(workspaceIdentifier);
} else {
this.workspaceConfigPath = URI.file(workspaceIdentifier.configPath);
}
this.workspaceConfiguration = this._register(new WorkspaceConfiguration());
this.baseConfigurationService = this._register(new GlobalConfigurationService(environmentService));
}
public getUnsupportedWorkspaceKeys(): string[] {
return this.hasFolderWorkspace() ? this._configuration.getFolderConfigurationModel(this.workspace.roots[0]).workspaceSettingsConfig.unsupportedKeys : [];
}
public initialize(trigger: boolean = true): TPromise<any> {
if (!this.workspace) {
return this.initializeWorkspace()
.then(() => super.initialize(trigger));
}
if (this.hasMultiFolderWorkspace()) {
return this.workspaceConfiguration.load(this.workspaceConfigPath)
.then(() => super.initialize(trigger));
}
return super.initialize(trigger);
}
public reloadConfiguration(section?: string): TPromise<any> {
const current = this._configuration;
return this.baseConfigurationService.reloadConfiguration()
.then(() => this.initialize(false)) // Reinitialize to ensure we are hitting the disk
.then(() => {
// Check and trigger
if (!this._configuration.equals(current)) {
this.triggerConfigurationChange();
}
return super.reloadConfiguration(section);
});
}
public handleWorkspaceFileEvents(event: FileChangesEvent): void {
TPromise.join(this.workspace.roots.map(folder => this.cachedFolderConfigs.get(folder).handleWorkspaceFileEvents(event))) // handle file event for each folder
.then(folderConfigurations =>
folderConfigurations.map((configuration, index) => ({ configuration, folder: this.workspace.roots[index] }))
.filter(folderConfiguration => !!folderConfiguration.configuration) // Filter folders which are not impacted by events
.map(folderConfiguration => this.updateFolderConfiguration(folderConfiguration.folder, folderConfiguration.configuration, true)) // Update the configuration of impacted folders
.reduce((result, value) => result || value, false)) // Check if the effective configuration of folder is changed
.then(changed => changed ? this.triggerConfigurationChange() : void 0); // Trigger event if changed
}
protected resetCaches(): void {
this.cachedFolderConfigs = new StrictResourceMap<FolderConfiguration<any>>();
this._configuration = new Configuration(<any>this.baseConfigurationService.configuration(), new ConfigurationModel<any>(), new StrictResourceMap<FolderConfigurationModel<any>>(), this.workspace);
this.initCachesForFolders(this.workspace.roots);
}
private initializeWorkspace(): TPromise<void> {
return (this.workspaceConfigPath ? this.initializeMulitFolderWorkspace() : this.initializeSingleFolderWorkspace())
.then(() => {
this._register(this.baseConfigurationService.onDidUpdateConfiguration(e => this.onBaseConfigurationChanged(e)));
});
}
// TODO@Sandeep use again once we can change workspace without window reload
// private onWorkspaceChange(configPath: URI): TPromise<void> {
// let workspaceName = this.workspace.name;
// this.workspaceConfigPath = configPath;
// // Reset the workspace if current workspace is single folder
// if (this.hasFolderWorkspace()) {
// this.folderPath = null;
// this.workspace = null;
// }
// // Update workspace configuration path with new path
// else {
// this.workspace.configuration = configPath;
// this.workspace.name = getWorkspaceLabel({ id: this.workspace.id, configPath: this.workspace.configuration.fsPath }, this.environmentService);
// }
// return this.initialize().then(() => {
// if (workspaceName !== this.workspace.name) {
// this._onDidChangeWorkspaceName.fire();
// }
// });
// }
private initializeMulitFolderWorkspace(): TPromise<void> {
this.registerWorkspaceConfigSchema();
return this.workspaceConfiguration.load(this.workspaceConfigPath)
.then(() => {
const workspaceConfigurationModel = this.workspaceConfiguration.workspaceConfigurationModel;
const workspaceFolders = this.parseWorkspaceFolders(workspaceConfigurationModel.folders);
if (!workspaceFolders.length) {
return TPromise.wrapError<void>(new Error('Invalid workspace configuraton file ' + this.workspaceConfigPath));
}
const workspaceId = (this.workspaceIdentifier as IWorkspaceIdentifier).id;
const workspaceName = getWorkspaceLabel({ id: workspaceId, configPath: this.workspaceConfigPath.fsPath }, this.environmentService);
this.workspace = new Workspace(workspaceId, workspaceName, workspaceFolders, this.workspaceConfigPath);
this.legacyWorkspace = new LegacyWorkspace(this.workspace.roots[0]);
this._register(this.workspaceConfiguration.onDidUpdateConfiguration(() => this.onWorkspaceConfigurationChanged()));
return null;
});
}
private parseWorkspaceFolders(configuredFolders: IStoredWorkspaceFolder[]): URI[] {
return coalesce(configuredFolders.map(configuredFolder => {
const path = configuredFolder.path;
if (!path) {
return void 0;
}
if (paths.isAbsolute(path)) {
return URI.file(path);
}
return URI.file(paths.join(paths.dirname(this.workspaceConfigPath.fsPath), path));
}));
}
private registerWorkspaceConfigSchema(): void {
const contributionRegistry = Registry.as<IJSONContributionRegistry>(JSONExtensions.JSONContribution);
if (!contributionRegistry.getSchemaContributions().schemas['vscode://schemas/workspaceConfig']) {
contributionRegistry.registerSchema('vscode://schemas/workspaceConfig', {
default: {
folders: [
{
path: ''
}
],
settings: {
}
},
required: ['folders'],
properties: {
'folders': {
minItems: 1,
uniqueItems: true,
description: nls.localize('workspaceConfig.folders.description', "List of folders to be loaded in the workspace. Must be a file path. e.g. `/root/folderA` or `./folderA` for a relative path that will be resolved against the location of the workspace file."),
items: {
type: 'object',
default: { path: '' },
properties: {
path: {
type: 'string',
description: nls.localize('workspaceConfig.folder.description', "A file path. e.g. `/root/folderA` or `./folderA` for a relative path that will be resolved against the location of the workspace file.")
}
}
}
},
'settings': {
type: 'object',
default: {},
description: nls.localize('workspaceConfig.settings.description', "Workspace settings"),
$ref: schemaId
}
}
});
}
}
private initializeSingleFolderWorkspace(): TPromise<void> {
return stat(this.folderPath.fsPath)
.then(workspaceStat => {
const ctime = isLinux ? workspaceStat.ino : workspaceStat.birthtime.getTime(); // On Linux, birthtime is ctime, so we cannot use it! We use the ino instead!
const id = createHash('md5').update(this.folderPath.fsPath).update(ctime ? String(ctime) : '').digest('hex');
const folder = URI.file(this.folderPath.fsPath);
this.workspace = new Workspace(id, paths.basename(this.folderPath.fsPath), [folder], null);
this.legacyWorkspace = new LegacyWorkspace(folder, ctime);
return TPromise.as(null);
});
}
private initCachesForFolders(folders: URI[]): void {
for (const folder of folders) {
this.cachedFolderConfigs.set(folder, this._register(new FolderConfiguration(folder, this.workspaceSettingsRootFolder, this.hasMultiFolderWorkspace() ? ConfigurationScope.RESOURCE : ConfigurationScope.WINDOW)));
this.updateFolderConfiguration(folder, new FolderConfigurationModel<any>(new FolderSettingsModel<any>(null), [], ConfigurationScope.RESOURCE), false);
}
}
protected updateConfiguration(folders: URI[] = this.workspace.roots): TPromise<boolean> {
return TPromise.join([...folders.map(folder => this.cachedFolderConfigs.get(folder).loadConfiguration()
.then(configuration => this.updateFolderConfiguration(folder, configuration, true)))])
.then(changed => changed.reduce((result, value) => result || value, false))
.then(changed => this.updateWorkspaceConfiguration(true) || changed);
}
private onBaseConfigurationChanged({ source, sourceConfig }: IConfigurationServiceEvent): void {
if (source === ConfigurationSource.Default) {
this.workspace.roots.forEach(folder => this._configuration.getFolderConfigurationModel(folder).update());
}
if (this._configuration.updateBaseConfiguration(<any>this.baseConfigurationService.configuration())) {
this._onDidUpdateConfiguration.fire({ source, sourceConfig });
}
}
private onWorkspaceConfigurationChanged(): void {
let configuredFolders = this.parseWorkspaceFolders(this.workspaceConfiguration.workspaceConfigurationModel.folders);
const foldersChanged = !equals(this.workspace.roots, configuredFolders, (r1, r2) => r1.fsPath === r2.fsPath);
if (foldersChanged) { // TODO@Sandeep be smarter here about detecting changes
this.workspace.roots = configuredFolders;
this.onFoldersChanged()
.then(configurationChanged => {
this._onDidChangeWorkspaceRoots.fire();
if (configurationChanged) {
this.triggerConfigurationChange();
}
} else {
c({
resource,
isDirectory: true,
children: children.map(child => { return { resource: URI.file(paths.join(resource.fsPath, child)) }; })
});
} else {
const configurationChanged = this.updateWorkspaceConfiguration(true);
if (configurationChanged) {
this.triggerConfigurationChange();
}
}
}
private onFoldersChanged(): TPromise<boolean> {
let configurationChangedOnRemoval = false;
// Remove the configurations of deleted folders
for (const key of this.cachedFolderConfigs.keys()) {
if (!this.workspace.roots.filter(folder => folder.toString() === key.toString())[0]) {
this.cachedFolderConfigs.delete(key);
if (this._configuration.deleteFolderConfiguration(key)) {
configurationChangedOnRemoval = true;
}
}
}
// Initialize the newly added folders
const toInitialize = this.workspace.roots.filter(folder => !this.cachedFolderConfigs.has(folder));
if (toInitialize.length) {
this.initCachesForFolders(toInitialize);
return this.updateConfiguration(toInitialize)
.then(changed => configurationChangedOnRemoval || changed);
} else if (configurationChangedOnRemoval) {
this.updateWorkspaceConfiguration(false);
return TPromise.as(true);
}
return TPromise.as(false);
}
private updateFolderConfiguration(folder: URI, folderConfiguration: FolderConfigurationModel<any>, compare: boolean): boolean {
let configurationChanged = this._configuration.updateFolderConfiguration(folder, folderConfiguration, compare);
if (this.hasFolderWorkspace()) {
// Workspace configuration changed
configurationChanged = this.updateWorkspaceConfiguration(compare) || configurationChanged;
}
return configurationChanged;
}
private updateWorkspaceConfiguration(compare: boolean): boolean {
const workspaceConfiguration = this.hasMultiFolderWorkspace() ? this.workspaceConfiguration.workspaceConfigurationModel.workspaceConfiguration : this._configuration.getFolderConfigurationModel(this.workspace.roots[0]);
return this._configuration.updateWorkspaceConfiguration(workspaceConfiguration, compare);
}
protected triggerConfigurationChange(): void {
this._onDidUpdateConfiguration.fire({ source: ConfigurationSource.Workspace, sourceConfig: this._configuration.getFolderConfigurationModel(this.workspace.roots[0]).contents });
}
});
});
}
class WorkspaceConfiguration extends Disposable {
export class WorkspaceConfiguration extends Disposable {
private _workspaceConfigPath: URI;
private _workspaceConfigurationWatcher: ConfigWatcher<WorkspaceConfigurationModel<any>>;
private _workspaceConfigurationWatcher: ConfigWatcher<WorkspaceConfigurationModel>;
private _workspaceConfigurationWatcherDisposables: IDisposable[] = [];
private _onDidUpdateConfiguration: Emitter<void> = this._register(new Emitter<void>());
public readonly onDidUpdateConfiguration: Event<void> = this._onDidUpdateConfiguration.event;
load(workspaceConfigPath: URI): TPromise<void> {
if (this._workspaceConfigPath && this._workspaceConfigPath.fsPath === workspaceConfigPath.fsPath) {
return this._reload();
return this.reload();
}
this._workspaceConfigPath = workspaceConfigPath;
this._workspaceConfigurationWatcherDisposables = dispose(this._workspaceConfigurationWatcherDisposables);
this.stopListeningToWatcher();
return new TPromise<void>((c, e) => {
this._workspaceConfigurationWatcher = new ConfigWatcher(this._workspaceConfigPath.fsPath, {
changeBufferDelay: 300, onError: error => errors.onUnexpectedError(error), defaultConfig: new WorkspaceConfigurationModel(null, this._workspaceConfigPath.fsPath), parse: (content: string, parseErrors: any[]) => {
changeBufferDelay: 300,
onError: error => errors.onUnexpectedError(error),
defaultConfig: new WorkspaceConfigurationModel(JSON.stringify({ folders: [] } as IStoredWorkspace, null, '\t'), this._workspaceConfigPath.fsPath),
parse: (content: string, parseErrors: any[]) => {
const workspaceConfigurationModel = new WorkspaceConfigurationModel(content, this._workspaceConfigPath.fsPath);
parseErrors = [...workspaceConfigurationModel.errors];
return workspaceConfigurationModel;
}, initCallback: () => c(null)
});
this._workspaceConfigurationWatcherDisposables.push(toDisposable(() => this._workspaceConfigurationWatcher.dispose()));
this._workspaceConfigurationWatcher.onDidUpdateConfiguration(() => this._onDidUpdateConfiguration.fire(), this, this._workspaceConfigurationWatcherDisposables);
this.listenToWatcher();
});
}
get workspaceConfigurationModel(): WorkspaceConfigurationModel<any> {
private get workspaceConfigurationModel(): WorkspaceConfigurationModel {
return this._workspaceConfigurationWatcher ? this._workspaceConfigurationWatcher.getConfig() : new WorkspaceConfigurationModel();
}
private _reload(): TPromise<void> {
return new TPromise<void>(c => this._workspaceConfigurationWatcher.reload(() => c(null)));
reload(): TPromise<void> {
this.stopListeningToWatcher();
return new TPromise<void>(c => this._workspaceConfigurationWatcher.reload(() => {
this.listenToWatcher();
c(null);
}));
}
getFolders(): IStoredWorkspaceFolder[] {
return this.workspaceConfigurationModel.folders;
}
setFolders(folders: IStoredWorkspaceFolder[], jsonEditingService: JSONEditingService): TPromise<void> {
return jsonEditingService.write(this._workspaceConfigPath, { key: 'folders', value: folders }, true)
.then(() => this.reload());
}
getConfiguration(): ConfigurationModel {
return this.workspaceConfigurationModel.workspaceConfiguration;
}
getWorkspaceSettings(): WorkspaceSettingsModel {
return this.workspaceConfigurationModel.workspaceSettingsModel;
}
private listenToWatcher() {
this._workspaceConfigurationWatcherDisposables.push(this._workspaceConfigurationWatcher);
this._workspaceConfigurationWatcher.onDidUpdateConfiguration(() => this._onDidUpdateConfiguration.fire(), this, this._workspaceConfigurationWatcherDisposables);
}
private stopListeningToWatcher() {
this._workspaceConfigurationWatcherDisposables = dispose(this._workspaceConfigurationWatcherDisposables);
}
dispose(): void {
@@ -650,15 +146,15 @@ class WorkspaceConfiguration extends Disposable {
}
}
class FolderConfiguration<T> extends Disposable {
export class FolderConfiguration extends Disposable {
private static RELOAD_CONFIGURATION_DELAY = 50;
private bulkFetchFromWorkspacePromise: TPromise<any>;
private workspaceFilePathToConfiguration: { [relativeWorkspacePath: string]: TPromise<ConfigurationModel<any>> };
private bulkFetchFromWorkspacePromise: TPromise;
private workspaceFilePathToConfiguration: { [relativeWorkspacePath: string]: TPromise<ConfigurationModel> };
private reloadConfigurationScheduler: RunOnceScheduler;
private reloadConfigurationEventEmitter: Emitter<FolderConfigurationModel<T>> = new Emitter<FolderConfigurationModel<T>>();
private reloadConfigurationEventEmitter: Emitter<FolderConfigurationModel> = new Emitter<FolderConfigurationModel>();
constructor(private folder: URI, private configFolderRelativePath: string, private scope: ConfigurationScope) {
super();
@@ -667,17 +163,17 @@ class FolderConfiguration<T> extends Disposable {
this.reloadConfigurationScheduler = this._register(new RunOnceScheduler(() => this.loadConfiguration().then(configuration => this.reloadConfigurationEventEmitter.fire(configuration), errors.onUnexpectedError), FolderConfiguration.RELOAD_CONFIGURATION_DELAY));
}
loadConfiguration(): TPromise<FolderConfigurationModel<T>> {
loadConfiguration(): TPromise<FolderConfigurationModel> {
// Load workspace locals
return this.loadWorkspaceConfigFiles().then(workspaceConfigFiles => {
// Consolidate (support *.json files in the workspace settings folder)
const workspaceSettingsConfig = <FolderSettingsModel<T>>workspaceConfigFiles[WORKSPACE_CONFIG_DEFAULT_PATH] || new FolderSettingsModel<T>(null);
const otherConfigModels = Object.keys(workspaceConfigFiles).filter(key => key !== WORKSPACE_CONFIG_DEFAULT_PATH).map(key => <ScopedConfigurationModel<T>>workspaceConfigFiles[key]);
return new FolderConfigurationModel<T>(workspaceSettingsConfig, otherConfigModels, this.scope);
const workspaceSettingsConfig = <FolderSettingsModel>workspaceConfigFiles[WORKSPACE_CONFIG_DEFAULT_PATH] || new FolderSettingsModel(null);
const otherConfigModels = Object.keys(workspaceConfigFiles).filter(key => key !== WORKSPACE_CONFIG_DEFAULT_PATH).map(key => <ScopedConfigurationModel>workspaceConfigFiles[key]);
return new FolderConfigurationModel(workspaceSettingsConfig, otherConfigModels, this.scope);
});
}
private loadWorkspaceConfigFiles<T>(): TPromise<{ [relativeWorkspacePath: string]: ConfigurationModel<T> }> {
private loadWorkspaceConfigFiles(): TPromise<{ [relativeWorkspacePath: string]: ConfigurationModel }> {
// once: when invoked for the first time we fetch json files that contribute settings
if (!this.bulkFetchFromWorkspacePromise) {
this.bulkFetchFromWorkspacePromise = resolveStat(this.toResource(this.configFolderRelativePath)).then(stat => {
@@ -704,7 +200,7 @@ class FolderConfiguration<T> extends Disposable {
return this.bulkFetchFromWorkspacePromise.then(() => TPromise.join(this.workspaceFilePathToConfiguration));
}
public handleWorkspaceFileEvents(event: FileChangesEvent): TPromise<FolderConfigurationModel<T>> {
public handleWorkspaceFileEvents(event: FileChangesEvent): TPromise<FolderConfigurationModel> {
const events = event.changes;
let affectedByChanges = false;
@@ -762,22 +258,22 @@ class FolderConfiguration<T> extends Disposable {
});
}
private createConfigModel<T>(content: IContent): ConfigurationModel<T> {
private createConfigModel(content: IContent): ConfigurationModel {
const path = this.toFolderRelativePath(content.resource);
if (path === WORKSPACE_CONFIG_DEFAULT_PATH) {
return new FolderSettingsModel<T>(content.value, content.resource.toString());
return new FolderSettingsModel(content.value, content.resource.toString());
} else {
const matches = /\/([^\.]*)*\.json/.exec(path);
if (matches && matches[1]) {
return new ScopedConfigurationModel<T>(content.value, content.resource.toString(), matches[1]);
return new ScopedConfigurationModel(content.value, content.resource.toString(), matches[1]);
}
}
return new CustomConfigurationModel<T>(null);
return new CustomConfigurationModel(null);
}
private isWorkspaceConfigurationFile(folderRelativePath: string): boolean {
return [WORKSPACE_CONFIG_DEFAULT_PATH, WORKSPACE_STANDALONE_CONFIGURATIONS.launch, WORKSPACE_STANDALONE_CONFIGURATIONS.tasks].some(p => p === folderRelativePath);
return [WORKSPACE_CONFIG_DEFAULT_PATH, WORKSPACE_STANDALONE_CONFIGURATIONS[TASKS_CONFIGURATION_KEY], WORKSPACE_STANDALONE_CONFIGURATIONS[LAUNCH_CONFIGURATION_KEY]].some(p => p === folderRelativePath);
}
private toResource(folderRelativePath: string): URI {
@@ -803,114 +299,4 @@ class FolderConfiguration<T> extends Disposable {
return false;
}
}
// node.hs helper functions
function resolveContents(resources: URI[]): TPromise<IContent[]> {
const contents: IContent[] = [];
return TPromise.join(resources.map(resource => {
return resolveContent(resource).then(content => {
contents.push(content);
});
})).then(() => contents);
}
function resolveContent(resource: URI): TPromise<IContent> {
return readFile(resource.fsPath).then(contents => ({ resource, value: contents.toString() }));
}
function resolveStat(resource: URI): TPromise<IStat> {
return new TPromise<IStat>((c, e) => {
extfs.readdir(resource.fsPath, (error, children) => {
if (error) {
if ((<any>error).code === 'ENOTDIR') {
c({ resource });
} else {
e(error);
}
} else {
c({
resource,
isDirectory: true,
children: children.map(child => { return { resource: URI.file(paths.join(resource.fsPath, child)) }; })
});
}
});
});
}
export class Configuration<T> extends BaseConfiguration<T> {
constructor(private _baseConfiguration: BaseConfiguration<T>, workspaceConfiguration: ConfigurationModel<T>, protected folders: StrictResourceMap<FolderConfigurationModel<T>>, workspace: Workspace) {
super(_baseConfiguration.defaults, _baseConfiguration.user, workspaceConfiguration, folders, workspace);
}
updateBaseConfiguration(baseConfiguration: BaseConfiguration<T>): boolean {
const current = new Configuration(this._baseConfiguration, this._workspaceConfiguration, this.folders, this._workspace);
this._baseConfiguration = baseConfiguration;
this._defaults = this._baseConfiguration.defaults;
this._user = this._baseConfiguration.user;
this.merge();
return !this.equals(current);
}
updateWorkspaceConfiguration(workspaceConfiguration: ConfigurationModel<T>, compare: boolean = true): boolean {
const current = new Configuration(this._baseConfiguration, this._workspaceConfiguration, this.folders, this._workspace);
this._workspaceConfiguration = workspaceConfiguration;
this.merge();
return compare && !this.equals(current);
}
updateFolderConfiguration(resource: URI, configuration: FolderConfigurationModel<T>, compare: boolean): boolean {
const current = this.getValue(null, { resource });
this.folders.set(resource, configuration);
this.mergeFolder(resource);
return compare && !objects.equals(current, this.getValue(null, { resource }));
}
deleteFolderConfiguration(folder: URI): boolean {
if (this._workspace && this._workspace.roots.length > 0 && this._workspace.roots[0].fsPath === folder.fsPath) {
// Do not remove workspace configuration
return false;
}
const changed = this.folders.get(folder).keys.length > 0;
this.folders.delete(folder);
this._foldersConsolidatedConfigurations.delete(folder);
return changed;
}
getFolderConfigurationModel(folder: URI): FolderConfigurationModel<T> {
return <FolderConfigurationModel<T>>this.folders.get(folder);
}
equals(other: any): boolean {
if (!other || !(other instanceof Configuration)) {
return false;
}
if (!objects.equals(this.getValue(), other.getValue())) {
return false;
}
if (this._foldersConsolidatedConfigurations.size !== other._foldersConsolidatedConfigurations.size) {
return false;
}
for (const resource of this._foldersConsolidatedConfigurations.keys()) {
if (!objects.equals(this.getValue(null, { resource }), other.getValue(null, { resource }))) {
return false;
}
}
return true;
}
}
}

314
src/vs/workbench/services/configuration/node/configurationEditingService.ts
View File

@@ -7,7 +7,6 @@
import nls = require('vs/nls');
import { TPromise } from 'vs/base/common/winjs.base';
import * as paths from 'vs/base/common/paths';
import URI from 'vs/base/common/uri';
import * as json from 'vs/base/common/json';
import * as encoding from 'vs/base/node/encoding';
@@ -21,23 +20,93 @@ import { EditOperation } from 'vs/editor/common/core/editOperation';
import { Registry } from 'vs/platform/registry/common/platform';
import { Range } from 'vs/editor/common/core/range';
import { Selection } from 'vs/editor/common/core/selection';
import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { ITextFileService } from 'vs/workbench/services/textfile/common/textfiles';
import { IConfigurationService, IConfigurationOverrides } from 'vs/platform/configuration/common/configuration';
import { keyFromOverrideIdentifier } from 'vs/platform/configuration/common/model';
import { WORKSPACE_CONFIG_DEFAULT_PATH, WORKSPACE_STANDALONE_CONFIGURATIONS } from 'vs/workbench/services/configuration/common/configuration';
import { IConfigurationService, IConfigurationOverrides, keyFromOverrideIdentifier, ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
import { WORKSPACE_CONFIG_DEFAULT_PATH, WORKSPACE_STANDALONE_CONFIGURATIONS, TASKS_CONFIGURATION_KEY, LAUNCH_CONFIGURATION_KEY } from 'vs/workbench/services/configuration/common/configuration';
import { IFileService } from 'vs/platform/files/common/files';
import { IConfigurationEditingService, ConfigurationEditingErrorCode, ConfigurationEditingError, ConfigurationTarget, IConfigurationValue, IConfigurationEditingOptions } from 'vs/workbench/services/configuration/common/configurationEditing';
import { ITextModelService, ITextEditorModel } from 'vs/editor/common/services/resolverService';
import { OVERRIDE_PROPERTY_PATTERN, IConfigurationRegistry, Extensions as ConfigurationExtensions, ConfigurationScope } from 'vs/platform/configuration/common/configurationRegistry';
import { IChoiceService, IMessageService, Severity } from 'vs/platform/message/common/message';
import { ICommandService } from 'vs/platform/commands/common/commands';
import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';
export enum ConfigurationEditingErrorCode {
/**
* Error when trying to write a configuration key that is not registered.
*/
ERROR_UNKNOWN_KEY,
/**
* Error when trying to write an invalid folder configuration key to folder settings.
*/
ERROR_INVALID_FOLDER_CONFIGURATION,
/**
* Error when trying to write to user target but not supported for provided key.
*/
ERROR_INVALID_USER_TARGET,
/**
* Error when trying to write to user target but not supported for provided key.
*/
ERROR_INVALID_WORKSPACE_TARGET,
/**
* Error when trying to write a configuration key to folder target
*/
ERROR_INVALID_FOLDER_TARGET,
/**
* Error when trying to write to the workspace configuration without having a workspace opened.
*/
ERROR_NO_WORKSPACE_OPENED,
/**
* Error when trying to write and save to the configuration file while it is dirty in the editor.
*/
ERROR_CONFIGURATION_FILE_DIRTY,
/**
* Error when trying to write to a configuration file that contains JSON errors.
*/
ERROR_INVALID_CONFIGURATION
}
export class ConfigurationEditingError extends Error {
constructor(message: string, public code: ConfigurationEditingErrorCode) {
super(message);
}
}
export interface IConfigurationValue {
key: string;
value: any;
}
export interface IConfigurationEditingOptions {
/**
* If `true`, do not saves the configuration. Default is `false`.
*/
donotSave?: boolean;
/**
* If `true`, do not notifies the error to user by showing the message box. Default is `false`.
*/
donotNotifyError?: boolean;
/**
* Scope of configuration to be written into.
*/
scopes?: IConfigurationOverrides;
}
interface IConfigurationEditOperation extends IConfigurationValue {
target: ConfigurationTarget;
jsonPath: json.JSONPath;
resource: URI;
isWorkspaceStandalone?: boolean;
workspaceStandAloneConfigurationKey?: string;
}
interface IValidationResult {
@@ -49,7 +118,7 @@ interface ConfigurationEditingOptions extends IConfigurationEditingOptions {
force?: boolean;
}
export class ConfigurationEditingService implements IConfigurationEditingService {
export class ConfigurationEditingService {
public _serviceBrand: any;
@@ -64,28 +133,28 @@ export class ConfigurationEditingService implements IConfigurationEditingService
@ITextFileService private textFileService: ITextFileService,
@IChoiceService private choiceService: IChoiceService,
@IMessageService private messageService: IMessageService,
@ICommandService private commandService: ICommandService
@ICommandService private commandService: ICommandService,
@IWorkbenchEditorService private editorService: IWorkbenchEditorService
) {
this.queue = new Queue<void>();
}
writeConfiguration(target: ConfigurationTarget, value: IConfigurationValue, options: IConfigurationEditingOptions = {}): TPromise<void> {
return this.queue.queue(() => this.doWriteConfiguration(target, value, options) // queue up writes to prevent race conditions
const operation = this.getConfigurationEditOperation(target, value, options.scopes || {});
return this.queue.queue(() => this.doWriteConfiguration(operation, options) // queue up writes to prevent race conditions
.then(() => null,
error => {
if (!options.donotNotifyError) {
this.onError(error, target, value, options.scopes);
this.onError(error, operation, options.scopes);
}
return TPromise.wrapError(error);
}));
}
private doWriteConfiguration(target: ConfigurationTarget, value: IConfigurationValue, options: ConfigurationEditingOptions): TPromise<void> {
const operation = this.getConfigurationEditOperation(target, value, options.scopes || {});
private doWriteConfiguration(operation: IConfigurationEditOperation, options: ConfigurationEditingOptions): TPromise<void> {
const checkDirtyConfiguration = !(options.force || options.donotSave);
const saveConfiguration = options.force || !options.donotSave;
return this.resolveAndValidate(target, operation, checkDirtyConfiguration, options.scopes || {})
return this.resolveAndValidate(operation.target, operation, checkDirtyConfiguration, options.scopes || {})
.then(reference => this.writeToBuffer(reference.object.textEditorModel, operation, saveConfiguration)
.then(() => reference.dispose()));
}
@@ -93,9 +162,7 @@ export class ConfigurationEditingService implements IConfigurationEditingService
private writeToBuffer(model: editorCommon.IModel, operation: IConfigurationEditOperation, save: boolean): TPromise<any> {
const edit = this.getEdits(model, operation)[0];
if (this.applyEditsToBuffer(edit, model) && save) {
return this.textFileService.save(operation.resource, { skipSaveParticipants: true /* programmatic change */ })
// Reload the configuration so that we make sure all parties are updated
.then(() => this.configurationService.reloadConfiguration());
return this.textFileService.save(operation.resource, { skipSaveParticipants: true /* programmatic change */ });
}
return TPromise.as(null);
}
@@ -113,45 +180,97 @@ export class ConfigurationEditingService implements IConfigurationEditingService
return false;
}
private onError(error: ConfigurationEditingError, target: ConfigurationTarget, value: IConfigurationValue, scopes: IConfigurationOverrides): void {
private onError(error: ConfigurationEditingError, operation: IConfigurationEditOperation, scopes: IConfigurationOverrides): void {
switch (error.code) {
case ConfigurationEditingErrorCode.ERROR_INVALID_CONFIGURATION:
this.onInvalidConfigurationError(error, target);
this.onInvalidConfigurationError(error, operation);
break;
case ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_DIRTY:
this.onConfigurationFileDirtyError(error, target, value, scopes);
this.onConfigurationFileDirtyError(error, operation, scopes);
break;
default:
this.messageService.show(Severity.Error, error.message);
}
}
private onInvalidConfigurationError(error: ConfigurationEditingError, target: ConfigurationTarget): void {
this.choiceService.choose(Severity.Error, error.message, [nls.localize('open', "Open Settings"), nls.localize('close', "Close")], 1)
.then(option => {
switch (option) {
case 0:
this.openSettings(target);
}
});
private onInvalidConfigurationError(error: ConfigurationEditingError, operation: IConfigurationEditOperation, ): void {
const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? nls.localize('openTasksConfiguration', "Open Tasks Configuration")
: operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? nls.localize('openLaunchConfiguration', "Open Launch Configuration")
: null;
if (openStandAloneConfigurationActionLabel) {
this.choiceService.choose(Severity.Error, error.message, [openStandAloneConfigurationActionLabel, nls.localize('close', "Close")], 1)
.then(option => {
switch (option) {
case 0:
this.openFile(operation.resource);
break;
}
});
} else {
this.choiceService.choose(Severity.Error, error.message, [nls.localize('open', "Open Settings"), nls.localize('close', "Close")], 1)
.then(option => {
switch (option) {
case 0:
this.openSettings(operation);
break;
}
});
}
}
private onConfigurationFileDirtyError(error: ConfigurationEditingError, target: ConfigurationTarget, value: IConfigurationValue, scopes: IConfigurationOverrides): void {
this.choiceService.choose(Severity.Error, error.message, [nls.localize('saveAndRetry', "Save Settings and Retry"), nls.localize('open', "Open Settings"), nls.localize('close', "Close")], 2)
.then(option => {
switch (option) {
case 0:
this.writeConfiguration(target, value, <ConfigurationEditingOptions>{ force: true, scopes });
break;
case 1:
this.openSettings(target);
break;
}
});
private onConfigurationFileDirtyError(error: ConfigurationEditingError, operation: IConfigurationEditOperation, scopes: IConfigurationOverrides): void {
const openStandAloneConfigurationActionLabel = operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY ? nls.localize('openTasksConfiguration', "Open Tasks Configuration")
: operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY ? nls.localize('openLaunchConfiguration', "Open Launch Configuration")
: null;
if (openStandAloneConfigurationActionLabel) {
this.choiceService.choose(Severity.Error, error.message, [nls.localize('saveAndRetry', "Save and Retry"), openStandAloneConfigurationActionLabel, nls.localize('close', "Close")], 2)
.then(option => {
switch (option) {
case 0:
const key = operation.key ? `${operation.workspaceStandAloneConfigurationKey}.${operation.key}` : operation.workspaceStandAloneConfigurationKey;
this.writeConfiguration(operation.target, { key, value: operation.value }, <ConfigurationEditingOptions>{ force: true, scopes });
break;
case 1:
this.openFile(operation.resource);
break;
}
});
} else {
this.choiceService.choose(Severity.Error, error.message, [nls.localize('saveAndRetry', "Save and Retry"), nls.localize('open', "Open Settings"), nls.localize('close', "Close")], 2)
.then(option => {
switch (option) {
case 0:
this.writeConfiguration(operation.target, { key: operation.key, value: operation.value }, <ConfigurationEditingOptions>{ force: true, scopes });
break;
case 1:
this.openSettings(operation);
break;
}
});
}
}
private openSettings(target: ConfigurationTarget): void {
this.commandService.executeCommand(ConfigurationTarget.USER === target ? 'workbench.action.openGlobalSettings' : 'workbench.action.openWorkspaceSettings');
private openSettings(operation: IConfigurationEditOperation): void {
switch (operation.target) {
case ConfigurationTarget.USER:
this.commandService.executeCommand('workbench.action.openGlobalSettings');
break;
case ConfigurationTarget.WORKSPACE:
this.commandService.executeCommand('workbench.action.openWorkspaceSettings');
break;
case ConfigurationTarget.WORKSPACE_FOLDER:
if (operation.resource) {
const workspaceFolder = this.contextService.getWorkspaceFolder(operation.resource);
if (workspaceFolder) {
this.commandService.executeCommand('_workbench.action.openFolderSettings', workspaceFolder);
}
}
break;
}
}
private openFile(resource: URI): void {
this.editorService.openEditor({ resource });
}
private wrapError<T = never>(code: ConfigurationEditingErrorCode, target: ConfigurationTarget, operation: IConfigurationEditOperation): TPromise<T> {
@@ -167,23 +286,46 @@ export class ConfigurationEditingService implements IConfigurationEditingService
case ConfigurationEditingErrorCode.ERROR_UNKNOWN_KEY: return nls.localize('errorUnknownKey', "Unable to write to {0} because {1} is not a registered configuration.", this.stringifyTarget(target), operation.key);
case ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_CONFIGURATION: return nls.localize('errorInvalidFolderConfiguration', "Unable to write to Folder Settings because {0} does not support the folder resource scope.", operation.key);
case ConfigurationEditingErrorCode.ERROR_INVALID_USER_TARGET: return nls.localize('errorInvalidUserTarget', "Unable to write to User Settings because {0} does not support for global scope.", operation.key);
case ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_TARGET: return nls.localize('errorInvalidWorkspaceTarget', "Unable to write to Workspace Settings because {0} does not support for workspace scope in a multi folder workspace.", operation.key);
case ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_TARGET: return nls.localize('errorInvalidFolderTarget', "Unable to write to Folder Settings because no resource is provided.");
case ConfigurationEditingErrorCode.ERROR_NO_WORKSPACE_OPENED: return nls.localize('errorNoWorkspaceOpened', "Unable to write to {0} because no workspace is opened. Please open a workspace first and try again.", this.stringifyTarget(target));
// User issues
case ConfigurationEditingErrorCode.ERROR_INVALID_CONFIGURATION: {
if (target === ConfigurationTarget.USER) {
return nls.localize('errorInvalidConfiguration', "Unable to write into settings. Please open **User Settings** to correct errors/warnings in the file and try again.");
if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
return nls.localize('errorInvalidTaskConfiguration', "Unable to write into tasks file. Please open **Tasks** file to correct errors/warnings in it and try again.");
}
return nls.localize('errorInvalidConfigurationWorkspace', "Unable to write into settings. Please open **Workspace Settings** to correct errors/warnings in the file and try again.");
if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
return nls.localize('errorInvalidLaunchConfiguration', "Unable to write into launch file. Please open **Launch** file to correct errors/warnings in it and try again.");
}
switch (target) {
case ConfigurationTarget.USER:
return nls.localize('errorInvalidConfiguration', "Unable to write into user settings. Please open **User Settings** file to correct errors/warnings in it and try again.");
case ConfigurationTarget.WORKSPACE:
return nls.localize('errorInvalidConfigurationWorkspace', "Unable to write into workspace settings. Please open **Workspace Settings** file to correct errors/warnings in the file and try again.");
case ConfigurationTarget.WORKSPACE_FOLDER:
const workspaceFolderName = this.contextService.getWorkspaceFolder(operation.resource).name;
return nls.localize('errorInvalidConfigurationFolder', "Unable to write into folder settings. Please open **Folder Settings** file under **{0}** folder to correct errors/warnings in it and try again.", workspaceFolderName);
}
return '';
};
case ConfigurationEditingErrorCode.ERROR_CONFIGURATION_FILE_DIRTY: {
if (target === ConfigurationTarget.USER) {
return nls.localize('errorConfigurationFileDirty', "Unable to write into settings because the file is dirty. Please save the **User Settings** file and try again.");
if (operation.workspaceStandAloneConfigurationKey === TASKS_CONFIGURATION_KEY) {
return nls.localize('errorTasksConfigurationFileDirty', "Unable to write into tasks file because the file is dirty. Please save the **Tasks Configuration** file and try again.");
}
return nls.localize('errorConfigurationFileDirtyWorkspace', "Unable to write into settings because the file is dirty. Please save the **Workspace Settings** file and try again.");
if (operation.workspaceStandAloneConfigurationKey === LAUNCH_CONFIGURATION_KEY) {
return nls.localize('errorLaunchConfigurationFileDirty', "Unable to write into launch file because the file is dirty. Please save the **Launch Configuration** file and try again.");
}
switch (target) {
case ConfigurationTarget.USER:
return nls.localize('errorConfigurationFileDirty', "Unable to write into user settings because the file is dirty. Please save the **User Settings** file and try again.");
case ConfigurationTarget.WORKSPACE:
return nls.localize('errorConfigurationFileDirtyWorkspace', "Unable to write into workspace settings because the file is dirty. Please save the **Workspace Settings** file and try again.");
case ConfigurationTarget.WORKSPACE_FOLDER:
const workspaceFolderName = this.contextService.getWorkspaceFolder(operation.resource).name;
return nls.localize('errorConfigurationFileDirtyFolder', "Unable to write into folder settings because the file is dirty. Please save the **Folder Settings** file under **{0}** folder and try again.", workspaceFolderName);
}
return '';
};
}
}
@@ -194,9 +336,10 @@ export class ConfigurationEditingService implements IConfigurationEditingService
return nls.localize('userTarget', "User Settings");
case ConfigurationTarget.WORKSPACE:
return nls.localize('workspaceTarget', "Workspace Settings");
case ConfigurationTarget.FOLDER:
case ConfigurationTarget.WORKSPACE_FOLDER:
return nls.localize('folderTarget', "Folder Settings");
}
return '';
}
private getEdits(model: editorCommon.IModel, edit: IConfigurationEditOperation): Edit[] {
@@ -228,7 +371,7 @@ export class ConfigurationEditingService implements IConfigurationEditingService
private hasParseErrors(model: editorCommon.IModel, operation: IConfigurationEditOperation): boolean {
// If we write to a workspace standalone file and replace the entire contents (no key provided)
// we can return here because any parse errors can safely be ignored since all contents are replaced
if (operation.isWorkspaceStandalone && !operation.key) {
if (operation.workspaceStandAloneConfigurationKey && !operation.key) {
return false;
}
const parseErrors: json.ParseError[] = [];
@@ -239,31 +382,40 @@ export class ConfigurationEditingService implements IConfigurationEditingService
private resolveAndValidate(target: ConfigurationTarget, operation: IConfigurationEditOperation, checkDirty: boolean, overrides: IConfigurationOverrides): TPromise<IReference<ITextEditorModel>> {
// Any key must be a known setting from the registry (unless this is a standalone config)
if (!operation.isWorkspaceStandalone) {
if (!operation.workspaceStandAloneConfigurationKey) {
const validKeys = this.configurationService.keys().default;
if (validKeys.indexOf(operation.key) < 0 && !OVERRIDE_PROPERTY_PATTERN.test(operation.key)) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_UNKNOWN_KEY, target, operation);
}
}
// Target cannot be user if is standalone
if (operation.isWorkspaceStandalone && target === ConfigurationTarget.USER) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_INVALID_USER_TARGET, target, operation);
if (operation.workspaceStandAloneConfigurationKey) {
// Global tasks and launches are not supported
if (target === ConfigurationTarget.USER) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_INVALID_USER_TARGET, target, operation);
}
// Workspace tasks and launches are not supported
if (this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE && operation.target === ConfigurationTarget.WORKSPACE) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_INVALID_WORKSPACE_TARGET, target, operation);
}
}
// Target cannot be workspace or folder if no workspace opened
if ((target === ConfigurationTarget.WORKSPACE || target === ConfigurationTarget.FOLDER) && !this.contextService.hasWorkspace()) {
if ((target === ConfigurationTarget.WORKSPACE || target === ConfigurationTarget.WORKSPACE_FOLDER) && this.contextService.getWorkbenchState() === WorkbenchState.EMPTY) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_NO_WORKSPACE_OPENED, target, operation);
}
if (target === ConfigurationTarget.FOLDER) {
if (target === ConfigurationTarget.WORKSPACE_FOLDER) {
if (!operation.resource) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_TARGET, target, operation);
}
const configurationProperties = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).getConfigurationProperties();
if (configurationProperties[operation.key].scope !== ConfigurationScope.RESOURCE) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_CONFIGURATION, target, operation);
if (!operation.workspaceStandAloneConfigurationKey) {
const configurationProperties = Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).getConfigurationProperties();
if (configurationProperties[operation.key].scope !== ConfigurationScope.RESOURCE) {
return this.wrapError(ConfigurationEditingErrorCode.ERROR_INVALID_FOLDER_CONFIGURATION, target, operation);
}
}
}
@@ -296,15 +448,15 @@ export class ConfigurationEditingService implements IConfigurationEditingService
// Check for prefix
if (config.key === key) {
const jsonPath = workspace && workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath ? [key] : [];
return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource, isWorkspaceStandalone: true };
const jsonPath = workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath ? [key] : [];
return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource, workspaceStandAloneConfigurationKey: key, target };
}
// Check for prefix.<setting>
const keyPrefix = `${key}.`;
if (config.key.indexOf(keyPrefix) === 0) {
const jsonPath = workspace && workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath ? [key, config.key.substr(keyPrefix.length)] : [config.key.substr(keyPrefix.length)];
return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource, isWorkspaceStandalone: true };
const jsonPath = workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath ? [key, config.key.substr(keyPrefix.length)] : [config.key.substr(keyPrefix.length)];
return { key: jsonPath[jsonPath.length - 1], jsonPath, value: config.value, resource, workspaceStandAloneConfigurationKey: key, target };
}
}
}
@@ -312,14 +464,14 @@ export class ConfigurationEditingService implements IConfigurationEditingService
let key = config.key;
let jsonPath = overrides.overrideIdentifier ? [keyFromOverrideIdentifier(overrides.overrideIdentifier), key] : [key];
if (target === ConfigurationTarget.USER) {
return { key, jsonPath, value: config.value, resource: URI.file(this.environmentService.appSettingsPath) };
return { key, jsonPath, value: config.value, resource: URI.file(this.environmentService.appSettingsPath), target };
}
const resource = this.getConfigurationFileResource(target, WORKSPACE_CONFIG_DEFAULT_PATH, overrides.resource);
if (workspace && workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath) {
if (workspace.configuration && resource && workspace.configuration.fsPath === resource.fsPath) {
jsonPath = ['settings', ...jsonPath];
}
return { key, jsonPath, value: config.value, resource };
return { key, jsonPath, value: config.value, resource, target };
}
private getConfigurationFileResource(target: ConfigurationTarget, relativePath: string, resource: URI): URI {
@@ -327,27 +479,29 @@ export class ConfigurationEditingService implements IConfigurationEditingService
return URI.file(this.environmentService.appSettingsPath);
}
const workspace = this.contextService.getWorkspace();
const workbenchState = this.contextService.getWorkbenchState();
if (workbenchState !== WorkbenchState.EMPTY) {
if (workspace) {
const workspace = this.contextService.getWorkspace();
if (target === ConfigurationTarget.WORKSPACE) {
return this.contextService.hasMultiFolderWorkspace() ? workspace.configuration : this.toResource(relativePath, workspace.roots[0]);
if (workbenchState === WorkbenchState.WORKSPACE) {
return workspace.configuration;
}
if (workbenchState === WorkbenchState.FOLDER) {
return workspace.folders[0].toResource(relativePath);
}
}
if (target === ConfigurationTarget.FOLDER && this.contextService.hasMultiFolderWorkspace()) {
if (target === ConfigurationTarget.WORKSPACE_FOLDER) {
if (resource) {
const root = this.contextService.getRoot(resource);
if (root) {
return this.toResource(relativePath, root);
const folder = this.contextService.getWorkspaceFolder(resource);
if (folder) {
return folder.toResource(relativePath);
}
}
}
}
return null;
}
private toResource(relativePath: string, root: URI): URI {
return URI.file(paths.join(root.fsPath, relativePath));
}
}

752
src/vs/workbench/services/configuration/node/configurationService.ts Normal file
View File

@@ -0,0 +1,752 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import URI from 'vs/base/common/uri';
import * as paths from 'vs/base/common/paths';
import { TPromise } from 'vs/base/common/winjs.base';
import { dirname } from 'path';
import * as assert from 'vs/base/common/assert';
import Event, { Emitter } from 'vs/base/common/event';
import { StrictResourceMap } from 'vs/base/common/map';
import { equals } from 'vs/base/common/objects';
import { Disposable } from 'vs/base/common/lifecycle';
import { Queue } from 'vs/base/common/async';
import { stat, writeFile } from 'vs/base/node/pfs';
import { IJSONContributionRegistry, Extensions as JSONExtensions } from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
import { IWorkspaceContextService, Workspace, WorkbenchState, IWorkspaceFolder, toWorkspaceFolders, IWorkspaceFoldersChangeEvent } from 'vs/platform/workspace/common/workspace';
import { FileChangesEvent } from 'vs/platform/files/common/files';
import { isLinux } from 'vs/base/common/platform';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { ConfigurationModel, ConfigurationChangeEvent, AllKeysConfigurationChangeEvent } from 'vs/platform/configuration/common/configurationModels';
import { IConfigurationChangeEvent, ConfigurationTarget, IConfigurationOverrides, keyFromOverrideIdentifier, isConfigurationOverrides, IConfigurationData } from 'vs/platform/configuration/common/configuration';
import { FolderConfigurationModel, Configuration, WorkspaceConfigurationChangeEvent } from 'vs/workbench/services/configuration/common/configurationModels';
import { IWorkspaceConfigurationService, WORKSPACE_CONFIG_FOLDER_DEFAULT_NAME, defaultSettingsSchemaId, userSettingsSchemaId, workspaceSettingsSchemaId, folderSettingsSchemaId } from 'vs/workbench/services/configuration/common/configuration';
import { ConfigurationService as GlobalConfigurationService } from 'vs/platform/configuration/node/configurationService';
import { Registry } from 'vs/platform/registry/common/platform';
import { IConfigurationNode, IConfigurationRegistry, Extensions, ConfigurationScope, settingsSchema, resourceSettingsSchema } from 'vs/platform/configuration/common/configurationRegistry';
import { createHash } from 'crypto';
import { getWorkspaceLabel, IWorkspacesService, IWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, IStoredWorkspaceFolder, isStoredWorkspaceFolder, IWorkspaceFolderCreationData } from 'vs/platform/workspaces/common/workspaces';
import { IWindowConfiguration } from 'vs/platform/windows/common/windows';
import { IExtensionService } from 'vs/platform/extensions/common/extensions';
import { ICommandService } from 'vs/platform/commands/common/commands';
import product from 'vs/platform/node/product';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
import { ConfigurationEditingService } from 'vs/workbench/services/configuration/node/configurationEditingService';
import { WorkspaceConfiguration, FolderConfiguration } from 'vs/workbench/services/configuration/node/configuration';
import { JSONEditingService } from 'vs/workbench/services/configuration/node/jsonEditingService';
import { Schemas } from 'vs/base/common/network';
import { massageFolderPathForWorkspace } from 'vs/platform/workspaces/node/workspaces';
import { distinct } from 'vs/base/common/arrays';
export class WorkspaceService extends Disposable implements IWorkspaceConfigurationService, IWorkspaceContextService {
public _serviceBrand: any;
private workspace: Workspace;
private _configuration: Configuration;
private baseConfigurationService: GlobalConfigurationService;
private workspaceConfiguration: WorkspaceConfiguration;
private cachedFolderConfigs: StrictResourceMap<FolderConfiguration>;
private workspaceEditingQueue: Queue<void>;
protected readonly _onDidChangeConfiguration: Emitter<IConfigurationChangeEvent> = this._register(new Emitter<IConfigurationChangeEvent>());
public readonly onDidChangeConfiguration: Event<IConfigurationChangeEvent> = this._onDidChangeConfiguration.event;
protected readonly _onDidChangeWorkspaceFolders: Emitter<IWorkspaceFoldersChangeEvent> = this._register(new Emitter<IWorkspaceFoldersChangeEvent>());
public readonly onDidChangeWorkspaceFolders: Event<IWorkspaceFoldersChangeEvent> = this._onDidChangeWorkspaceFolders.event;
protected readonly _onDidChangeWorkspaceName: Emitter<void> = this._register(new Emitter<void>());
public readonly onDidChangeWorkspaceName: Event<void> = this._onDidChangeWorkspaceName.event;
protected readonly _onDidChangeWorkbenchState: Emitter<WorkbenchState> = this._register(new Emitter<WorkbenchState>());
public readonly onDidChangeWorkbenchState: Event<WorkbenchState> = this._onDidChangeWorkbenchState.event;
private configurationEditingService: ConfigurationEditingService;
private jsonEditingService: JSONEditingService;
constructor(private environmentService: IEnvironmentService, private workspacesService: IWorkspacesService, private workspaceSettingsRootFolder: string = WORKSPACE_CONFIG_FOLDER_DEFAULT_NAME) {
super();
this.workspaceConfiguration = this._register(new WorkspaceConfiguration());
this._register(this.workspaceConfiguration.onDidUpdateConfiguration(() => this.onWorkspaceConfigurationChanged()));
this.baseConfigurationService = this._register(new GlobalConfigurationService(environmentService));
this._register(this.baseConfigurationService.onDidChangeConfiguration(e => this.onBaseConfigurationChanged(e)));
this._register(Registry.as<IConfigurationRegistry>(Extensions.Configuration).onDidRegisterConfiguration(e => this.registerConfigurationSchemas()));
this.workspaceEditingQueue = new Queue<void>();
}
// Workspace Context Service Impl
public getWorkspace(): Workspace {
return this.workspace;
}
public getWorkbenchState(): WorkbenchState {
// Workspace has configuration file
if (this.workspace.configuration) {
return WorkbenchState.WORKSPACE;
}
// Folder has single root
if (this.workspace.folders.length === 1) {
return WorkbenchState.FOLDER;
}
// Empty
return WorkbenchState.EMPTY;
}
public getWorkspaceFolder(resource: URI): IWorkspaceFolder {
return this.workspace.getFolder(resource);
}
public addFolders(foldersToAdd: IWorkspaceFolderCreationData[]): TPromise<void> {
assert.ok(this.jsonEditingService, 'Workbench is not initialized yet');
return this.workspaceEditingQueue.queue(() => this.doAddFolders(foldersToAdd));
}
public removeFolders(foldersToRemove: URI[]): TPromise<void> {
assert.ok(this.jsonEditingService, 'Workbench is not initialized yet');
return this.workspaceEditingQueue.queue(() => this.doRemoveFolders(foldersToRemove));
}
public isInsideWorkspace(resource: URI): boolean {
return !!this.getWorkspaceFolder(resource);
}
public isCurrentWorkspace(workspaceIdentifier: ISingleFolderWorkspaceIdentifier | IWorkspaceIdentifier): boolean {
switch (this.getWorkbenchState()) {
case WorkbenchState.FOLDER:
return isSingleFolderWorkspaceIdentifier(workspaceIdentifier) && this.pathEquals(this.workspace.folders[0].uri.fsPath, workspaceIdentifier);
case WorkbenchState.WORKSPACE:
return isWorkspaceIdentifier(workspaceIdentifier) && this.workspace.id === workspaceIdentifier.id;
}
return false;
}
private doAddFolders(foldersToAdd: IWorkspaceFolderCreationData[]): TPromise<void> {
if (this.getWorkbenchState() !== WorkbenchState.WORKSPACE) {
return TPromise.as(void 0); // we need a workspace to begin with
}
const currentWorkspaceFolders = this.getWorkspace().folders;
const currentWorkspaceFolderUris = currentWorkspaceFolders.map(folder => folder.uri);
const currentStoredFolders = currentWorkspaceFolders.map(folder => folder.raw);
const storedFoldersToAdd: IStoredWorkspaceFolder[] = [];
const workspaceConfigFolder = dirname(this.getWorkspace().configuration.fsPath);
foldersToAdd.forEach(folderToAdd => {
if (this.contains(currentWorkspaceFolderUris, folderToAdd.uri)) {
return; // already existing
}
let storedFolder: IStoredWorkspaceFolder;
// File resource: use "path" property
if (folderToAdd.uri.scheme === Schemas.file) {
storedFolder = {
path: massageFolderPathForWorkspace(folderToAdd.uri.fsPath, workspaceConfigFolder, currentStoredFolders)
};
}
// Any other resource: use "uri" property
else {
storedFolder = {
uri: folderToAdd.uri.toString(true)
};
}
if (folderToAdd.name) {
storedFolder.name = folderToAdd.name;
}
storedFoldersToAdd.push(storedFolder);
});
if (storedFoldersToAdd.length > 0) {
return this.setFolders([...currentStoredFolders, ...storedFoldersToAdd]);
}
return TPromise.as(void 0);
}
private doRemoveFolders(foldersToRemove: URI[]): TPromise<void> {
if (this.getWorkbenchState() !== WorkbenchState.WORKSPACE) {
return TPromise.as(void 0); // we need a workspace to begin with
}
const currentWorkspaceFolders = this.getWorkspace().folders;
const currentStoredFolders = currentWorkspaceFolders.map(folder => folder.raw);
const newStoredFolders: IStoredWorkspaceFolder[] = currentStoredFolders.filter((folder, index) => {
if (!isStoredWorkspaceFolder(folder)) {
return true; // keep entries which are unrelated
}
return !this.contains(foldersToRemove, currentWorkspaceFolders[index].uri); // keep entries which are unrelated
});
if (newStoredFolders.length !== currentStoredFolders.length) {
return this.setFolders(newStoredFolders);
}
return TPromise.as(void 0);
}
private setFolders(folders: IStoredWorkspaceFolder[]): TPromise<void> {
return this.workspaceConfiguration.setFolders(folders, this.jsonEditingService)
.then(() => this.onWorkspaceConfigurationChanged());
}
private contains(resources: URI[], toCheck: URI): boolean {
return resources.some(resource => {
if (isLinux) {
return resource.toString() === toCheck.toString();
}
return resource.toString().toLowerCase() === toCheck.toString().toLowerCase();
});
}
// Workspace Configuration Service Impl
getConfigurationData(): IConfigurationData {
return this._configuration.toData();
}
getConfiguration<T>(): T
getConfiguration<T>(section: string): T
getConfiguration<T>(overrides: IConfigurationOverrides): T
getConfiguration<T>(section: string, overrides: IConfigurationOverrides): T
getConfiguration(arg1?: any, arg2?: any): any {
const section = typeof arg1 === 'string' ? arg1 : void 0;
const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : void 0;
return this._configuration.getSection(section, overrides);
}
getValue<T>(key: string, overrides?: IConfigurationOverrides): T {
return this._configuration.getValue(key, overrides);
}
updateValue(key: string, value: any): TPromise<void>
updateValue(key: string, value: any, overrides: IConfigurationOverrides): TPromise<void>
updateValue(key: string, value: any, target: ConfigurationTarget): TPromise<void>
updateValue(key: string, value: any, overrides: IConfigurationOverrides, target: ConfigurationTarget): TPromise<void>
updateValue(key: string, value: any, overrides: IConfigurationOverrides, target: ConfigurationTarget, donotNotifyError: boolean): TPromise<void>
updateValue(key: string, value: any, arg3?: any, arg4?: any, donotNotifyError?: any): TPromise<void> {
assert.ok(this.configurationEditingService, 'Workbench is not initialized yet');
const overrides = isConfigurationOverrides(arg3) ? arg3 : void 0;
const target = this.deriveConfigurationTarget(key, value, overrides, overrides ? arg4 : arg3);
return target ? this.writeConfigurationValue(key, value, target, overrides, donotNotifyError)
: TPromise.as(null);
}
reloadConfiguration(folder?: IWorkspaceFolder, key?: string): TPromise<void> {
if (folder) {
return this.reloadWorkspaceFolderConfiguration(folder, key);
}
return this.reloadUserConfiguration()
.then(() => this.reloadWorkspaceConfiguration())
.then(() => this.loadConfiguration());
}
inspect<T>(key: string, overrides?: IConfigurationOverrides): {
default: T,
user: T,
workspace: T,
workspaceFolder: T,
memory?: T,
value: T
} {
return this._configuration.lookup<T>(key);
}
keys(): {
default: string[];
user: string[];
workspace: string[];
workspaceFolder: string[];
} {
return this._configuration.keys();
}
getUnsupportedWorkspaceKeys(): string[] {
const unsupportedWorkspaceKeys = [...this.workspaceConfiguration.getWorkspaceSettings().unsupportedKeys];
for (const folder of this.workspace.folders) {
unsupportedWorkspaceKeys.push(...this._configuration.getFolderConfigurationModel(folder.uri).workspaceSettingsConfig.unsupportedKeys);
}
return distinct(unsupportedWorkspaceKeys);
}
initialize(arg: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | IWindowConfiguration): TPromise<any> {
return this.createWorkspace(arg)
.then(workspace => this.updateWorkspaceAndInitializeConfiguration(workspace));
}
setInstantiationService(instantiationService: IInstantiationService): void {
this.configurationEditingService = instantiationService.createInstance(ConfigurationEditingService);
this.jsonEditingService = instantiationService.createInstance(JSONEditingService);
}
handleWorkspaceFileEvents(event: FileChangesEvent): TPromise<void> {
switch (this.getWorkbenchState()) {
case WorkbenchState.FOLDER:
return this.onSingleFolderFileChanges(event);
case WorkbenchState.WORKSPACE:
return this.onWorkspaceFileChanges(event);
}
return TPromise.as(void 0);
}
private createWorkspace(arg: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | IWindowConfiguration): TPromise<Workspace> {
if (isWorkspaceIdentifier(arg)) {
return this.createMulitFolderWorkspace(arg);
}
if (isSingleFolderWorkspaceIdentifier(arg)) {
return this.createSingleFolderWorkspace(arg);
}
return this.createEmptyWorkspace(arg);
}
private createMulitFolderWorkspace(workspaceIdentifier: IWorkspaceIdentifier): TPromise<Workspace> {
const workspaceConfigPath = URI.file(workspaceIdentifier.configPath);
return this.workspaceConfiguration.load(workspaceConfigPath)
.then(() => {
const workspaceFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), URI.file(paths.dirname(workspaceConfigPath.fsPath)));
const workspaceId = workspaceIdentifier.id;
const workspaceName = getWorkspaceLabel({ id: workspaceId, configPath: workspaceConfigPath.fsPath }, this.environmentService);
return new Workspace(workspaceId, workspaceName, workspaceFolders, workspaceConfigPath);
});
}
private createSingleFolderWorkspace(singleFolderWorkspaceIdentifier: ISingleFolderWorkspaceIdentifier): TPromise<Workspace> {
const folderPath = URI.file(singleFolderWorkspaceIdentifier);
return stat(folderPath.fsPath)
.then(workspaceStat => {
const ctime = isLinux ? workspaceStat.ino : workspaceStat.birthtime.getTime(); // On Linux, birthtime is ctime, so we cannot use it! We use the ino instead!
const id = createHash('md5').update(folderPath.fsPath).update(ctime ? String(ctime) : '').digest('hex');
const folder = URI.file(folderPath.fsPath);
return new Workspace(id, paths.basename(folderPath.fsPath), toWorkspaceFolders([{ path: folder.fsPath }]), null, ctime);
});
}
private createEmptyWorkspace(configuration: IWindowConfiguration): TPromise<Workspace> {
let id = configuration.backupPath ? URI.from({ path: paths.basename(configuration.backupPath), scheme: 'empty' }).toString() : '';
return TPromise.as(new Workspace(id));
}
private updateWorkspaceAndInitializeConfiguration(workspace: Workspace): TPromise<void> {
let folderChanges: IWorkspaceFoldersChangeEvent;
if (this.workspace) {
const currentState = this.getWorkbenchState();
const currentWorkspacePath = this.workspace.configuration ? this.workspace.configuration.fsPath : void 0;
const currentFolders = this.workspace.folders;
this.workspace.update(workspace);
const newState = this.getWorkbenchState();
if (newState !== currentState) {
this._onDidChangeWorkbenchState.fire(newState);
}
const newWorkspacePath = this.workspace.configuration ? this.workspace.configuration.fsPath : void 0;
if (newWorkspacePath !== currentWorkspacePath || newState !== currentState) {
this._onDidChangeWorkspaceName.fire();
}
folderChanges = this.compareFolders(currentFolders, this.workspace.folders);
} else {
this.workspace = workspace;
}
return this.initializeConfiguration().then(() => {
// Trigger folders change after configuration initialization so that configuration is up to date.
if (folderChanges && (folderChanges.added.length || folderChanges.removed.length || folderChanges.changed.length)) {
this._onDidChangeWorkspaceFolders.fire(folderChanges);
}
});
}
private compareFolders(currentFolders: IWorkspaceFolder[], newFolders: IWorkspaceFolder[]): IWorkspaceFoldersChangeEvent {
const result = { added: [], removed: [], changed: [] };
result.added = newFolders.filter(newFolder => !currentFolders.some(currentFolder => newFolder.uri.toString() === currentFolder.uri.toString()));
for (let currentIndex = 0; currentIndex < currentFolders.length; currentIndex++) {
let currentFolder = currentFolders[currentIndex];
let newIndex = 0;
for (newIndex = 0; newIndex < newFolders.length && currentFolder.uri.toString() !== newFolders[newIndex].uri.toString(); newIndex++) { }
if (newIndex < newFolders.length) {
if (currentIndex !== newIndex || currentFolder.name !== newFolders[newIndex].name) {
result.changed.push(currentFolder);
}
} else {
result.removed.push(currentFolder);
}
}
return result;
}
private initializeConfiguration(): TPromise<void> {
this.registerConfigurationSchemas();
return this.loadConfiguration();
}
private reloadUserConfiguration(key?: string): TPromise<void> {
return this.baseConfigurationService.reloadConfiguration();
}
private reloadWorkspaceConfiguration(key?: string): TPromise<void> {
const workbenchState = this.getWorkbenchState();
if (workbenchState === WorkbenchState.FOLDER) {
return this.onWorkspaceFolderConfigurationChanged(this.workspace.folders[0], key);
}
if (workbenchState === WorkbenchState.WORKSPACE) {
return this.workspaceConfiguration.reload().then(() => this.onWorkspaceConfigurationChanged());
}
return TPromise.as(null);
}
private reloadWorkspaceFolderConfiguration(folder: IWorkspaceFolder, key?: string): TPromise<void> {
return this.onWorkspaceFolderConfigurationChanged(folder, key);
}
private loadConfiguration(): TPromise<void> {
// reset caches
this.cachedFolderConfigs = new StrictResourceMap<FolderConfiguration>();
const folders = this.workspace.folders;
return this.loadFolderConfigurations(folders)
.then((folderConfigurations) => {
let workspaceConfiguration = this.getWorkspaceConfigurationModel(folderConfigurations);
const folderConfigurationModels = new StrictResourceMap<FolderConfigurationModel>();
folderConfigurations.forEach((folderConfiguration, index) => folderConfigurationModels.set(folders[index].uri, folderConfiguration));
const currentConfiguration = this._configuration;
this._configuration = new Configuration(this.baseConfigurationService.configuration.defaults, this.baseConfigurationService.configuration.user, workspaceConfiguration, folderConfigurationModels, new ConfigurationModel(), new StrictResourceMap<ConfigurationModel>(), this.getWorkbenchState() !== WorkbenchState.EMPTY ? this.workspace : null); //TODO: Sandy Avoid passing null
if (currentConfiguration) {
const changedKeys = this._configuration.compare(currentConfiguration);
this.triggerConfigurationChange(new ConfigurationChangeEvent().change(changedKeys), ConfigurationTarget.WORKSPACE);
} else {
this._onDidChangeConfiguration.fire(new AllKeysConfigurationChangeEvent(this._configuration.allKeys(), ConfigurationTarget.WORKSPACE, this.getTargetConfiguration(ConfigurationTarget.WORKSPACE)));
}
});
}
private getWorkspaceConfigurationModel(folderConfigurations: FolderConfigurationModel[]): ConfigurationModel {
switch (this.getWorkbenchState()) {
case WorkbenchState.FOLDER:
return folderConfigurations[0];
case WorkbenchState.WORKSPACE:
return this.workspaceConfiguration.getConfiguration();
default:
return new ConfigurationModel();
}
}
private registerConfigurationSchemas(): void {
if (this.workspace) {
const jsonRegistry = Registry.as<IJSONContributionRegistry>(JSONExtensions.JSONContribution);
jsonRegistry.registerSchema(defaultSettingsSchemaId, settingsSchema);
jsonRegistry.registerSchema(userSettingsSchemaId, settingsSchema);
if (WorkbenchState.WORKSPACE === this.getWorkbenchState()) {
jsonRegistry.registerSchema(workspaceSettingsSchemaId, settingsSchema);
jsonRegistry.registerSchema(folderSettingsSchemaId, resourceSettingsSchema);
} else {
jsonRegistry.registerSchema(workspaceSettingsSchemaId, settingsSchema);
jsonRegistry.registerSchema(folderSettingsSchemaId, settingsSchema);
}
}
}
private onBaseConfigurationChanged(e: IConfigurationChangeEvent): void {
if (this.workspace && this._configuration) {
if (e.source === ConfigurationTarget.DEFAULT) {
this.workspaceConfiguration.getWorkspaceSettings().update();
this.workspace.folders.forEach(folder => this._configuration.getFolderConfigurationModel(folder.uri).update());
this._configuration.updateDefaultConfiguration(this.baseConfigurationService.configuration.defaults);
this.triggerConfigurationChange(new ConfigurationChangeEvent().change(e.affectedKeys), e.source);
} else {
let keys = this._configuration.updateUserConfiguration(this.baseConfigurationService.configuration.user);
this.triggerConfigurationChange(keys, e.source);
}
}
}
private onWorkspaceConfigurationChanged(): TPromise<void> {
if (this.workspace && this.workspace.configuration && this._configuration) {
const workspaceConfigurationChangeEvent = this._configuration.updateWorkspaceConfiguration(this.workspaceConfiguration.getConfiguration());
let configuredFolders = toWorkspaceFolders(this.workspaceConfiguration.getFolders(), URI.file(paths.dirname(this.workspace.configuration.fsPath)));
const changes = this.compareFolders(this.workspace.folders, configuredFolders);
if (changes.added.length || changes.removed.length || changes.changed.length) {
this.workspace.folders = configuredFolders;
return this.onFoldersChanged()
.then(foldersConfigurationChangeEvent => {
this.triggerConfigurationChange(foldersConfigurationChangeEvent.change(workspaceConfigurationChangeEvent), ConfigurationTarget.WORKSPACE_FOLDER);
this._onDidChangeWorkspaceFolders.fire(changes);
});
} else {
this.triggerConfigurationChange(workspaceConfigurationChangeEvent, ConfigurationTarget.WORKSPACE);
}
}
return TPromise.as(null);
}
private onWorkspaceFileChanges(event: FileChangesEvent): TPromise<void> {
return TPromise.join(this.workspace.folders.map(folder =>
// handle file event for each folder
this.cachedFolderConfigs.get(folder.uri).handleWorkspaceFileEvents(event)
// Update folder configuration if handled
.then(folderConfiguration => folderConfiguration ? this._configuration.updateFolderConfiguration(folder.uri, folderConfiguration) : new ConfigurationChangeEvent()))
).then(changeEvents => {
const consolidateChangeEvent = changeEvents.reduce((consolidated, e) => consolidated.change(e), new ConfigurationChangeEvent());
this.triggerConfigurationChange(consolidateChangeEvent, ConfigurationTarget.WORKSPACE_FOLDER);
});
}
private onSingleFolderFileChanges(event: FileChangesEvent): TPromise<void> {
const folder = this.workspace.folders[0];
return this.cachedFolderConfigs.get(folder.uri).handleWorkspaceFileEvents(event)
.then(folderConfiguration => {
if (folderConfiguration) {
// File change handled
this._configuration.updateFolderConfiguration(folder.uri, folderConfiguration);
const workspaceChangedKeys = this._configuration.updateWorkspaceConfiguration(folderConfiguration);
this.triggerConfigurationChange(workspaceChangedKeys, ConfigurationTarget.WORKSPACE);
}
});
}
private onWorkspaceFolderConfigurationChanged(folder: IWorkspaceFolder, key?: string): TPromise<void> {
this.disposeFolderConfiguration(folder);
return this.loadFolderConfigurations([folder])
.then(([folderConfiguration]) => {
const folderChangedKeys = this._configuration.updateFolderConfiguration(folder.uri, folderConfiguration);
if (this.getWorkbenchState() === WorkbenchState.FOLDER) {
const workspaceChangedKeys = this._configuration.updateWorkspaceConfiguration(folderConfiguration);
this.triggerConfigurationChange(workspaceChangedKeys, ConfigurationTarget.WORKSPACE);
} else {
this.triggerConfigurationChange(folderChangedKeys, ConfigurationTarget.WORKSPACE_FOLDER);
}
});
}
private onFoldersChanged(): TPromise<ConfigurationChangeEvent> {
let changeEvent = new ConfigurationChangeEvent();
// Remove the configurations of deleted folders
for (const key of this.cachedFolderConfigs.keys()) {
if (!this.workspace.folders.filter(folder => folder.uri.toString() === key.toString())[0]) {
this.cachedFolderConfigs.delete(key);
changeEvent = changeEvent.change(this._configuration.deleteFolderConfiguration(key));
}
}
const toInitialize = this.workspace.folders.filter(folder => !this.cachedFolderConfigs.has(folder.uri));
if (toInitialize.length) {
return this.loadFolderConfigurations(toInitialize)
.then(folderConfigurations => {
folderConfigurations.forEach((folderConfiguration, index) => {
changeEvent = changeEvent.change(this._configuration.updateFolderConfiguration(toInitialize[index].uri, folderConfiguration));
});
return changeEvent;
});
}
return TPromise.as(changeEvent);
}
private loadFolderConfigurations(folders: IWorkspaceFolder[]): TPromise<FolderConfigurationModel[]> {
return TPromise.join([...folders.map(folder => {
const folderConfiguration = new FolderConfiguration(folder.uri, this.workspaceSettingsRootFolder, this.getWorkbenchState() === WorkbenchState.WORKSPACE ? ConfigurationScope.RESOURCE : ConfigurationScope.WINDOW);
this.cachedFolderConfigs.set(folder.uri, this._register(folderConfiguration));
return folderConfiguration.loadConfiguration();
})]);
}
private writeConfigurationValue(key: string, value: any, target: ConfigurationTarget, overrides: IConfigurationOverrides, donotNotifyError: boolean): TPromise<void> {
if (target === ConfigurationTarget.DEFAULT) {
return TPromise.wrapError(new Error('Invalid configuration target'));
}
if (target === ConfigurationTarget.MEMORY) {
this._configuration.updateValue(key, value, overrides);
this.triggerConfigurationChange(new ConfigurationChangeEvent().change(overrides.overrideIdentifier ? [keyFromOverrideIdentifier(overrides.overrideIdentifier)] : [key], overrides.resource), target);
return TPromise.as(null);
}
return this.configurationEditingService.writeConfiguration(target, { key, value }, { scopes: overrides, donotNotifyError })
.then(() => {
switch (target) {
case ConfigurationTarget.USER:
return this.reloadUserConfiguration();
case ConfigurationTarget.WORKSPACE:
return this.reloadWorkspaceConfiguration();
case ConfigurationTarget.WORKSPACE_FOLDER:
const workspaceFolder = overrides && overrides.resource ? this.workspace.getFolder(overrides.resource) : null;
if (workspaceFolder) {
return this.reloadWorkspaceFolderConfiguration(this.workspace.getFolder(overrides.resource), key);
}
}
return null;
});
}
private deriveConfigurationTarget(key: string, value: any, overrides: IConfigurationOverrides, target: ConfigurationTarget): ConfigurationTarget {
if (target) {
return target;
}
if (value === void 0) {
// Ignore. But expected is to remove the value from all targets
return void 0;
}
const inspect = this.inspect(key, overrides);
if (equals(value, inspect.value)) {
// No change. So ignore.
return void 0;
}
if (inspect.workspaceFolder !== void 0) {
return ConfigurationTarget.WORKSPACE_FOLDER;
}
if (inspect.workspace !== void 0) {
return ConfigurationTarget.WORKSPACE;
}
return ConfigurationTarget.USER;
}
private triggerConfigurationChange(configurationEvent: ConfigurationChangeEvent, target: ConfigurationTarget): void {
if (configurationEvent.affectedKeys.length) {
configurationEvent.telemetryData(target, this.getTargetConfiguration(target));
this._onDidChangeConfiguration.fire(new WorkspaceConfigurationChangeEvent(configurationEvent, this.workspace));
}
}
private getTargetConfiguration(target: ConfigurationTarget): any {
switch (target) {
case ConfigurationTarget.DEFAULT:
return this._configuration.defaults.contents;
case ConfigurationTarget.USER:
return this._configuration.user.contents;
case ConfigurationTarget.WORKSPACE:
return this._configuration.workspace.contents;
}
return {};
}
private pathEquals(path1: string, path2: string): boolean {
if (!isLinux) {
path1 = path1.toLowerCase();
path2 = path2.toLowerCase();
}
return path1 === path2;
}
private disposeFolderConfiguration(folder: IWorkspaceFolder): void {
const folderConfiguration = this.cachedFolderConfigs.get(folder.uri);
if (folderConfiguration) {
folderConfiguration.dispose();
}
}
}
interface IExportedConfigurationNode {
name: string;
description: string;
default: any;
type: string | string[];
enum?: any[];
enumDescriptions?: string[];
}
interface IConfigurationExport {
settings: IExportedConfigurationNode[];
buildTime: number;
commit: string;
buildNumber: number;
}
export class DefaultConfigurationExportHelper {
constructor(
@IEnvironmentService environmentService: IEnvironmentService,
@IExtensionService private extensionService: IExtensionService,
@ICommandService private commandService: ICommandService) {
if (environmentService.args['export-default-configuration']) {
this.writeConfigModelAndQuit(environmentService.args['export-default-configuration']);
}
}
private writeConfigModelAndQuit(targetPath: string): TPromise<void> {
return this.extensionService.onReady()
.then(() => this.writeConfigModel(targetPath))
.then(() => this.commandService.executeCommand('workbench.action.quit'))
.then(() => { });
}
private writeConfigModel(targetPath: string): TPromise<void> {
const config = this.getConfigModel();
const resultString = JSON.stringify(config, undefined, ' ');
return writeFile(targetPath, resultString);
}
private getConfigModel(): IConfigurationExport {
const configurations = Registry.as<IConfigurationRegistry>(Extensions.Configuration).getConfigurations().slice();
const settings: IExportedConfigurationNode[] = [];
const processConfig = (config: IConfigurationNode) => {
if (config.properties) {
for (let name in config.properties) {
const prop = config.properties[name];
const propDetails: IExportedConfigurationNode = {
name,
description: prop.description,
default: prop.default,
type: prop.type
};
if (prop.enum) {
propDetails.enum = prop.enum;
}
if (prop.enumDescriptions) {
propDetails.enumDescriptions = prop.enumDescriptions;
}
settings.push(propDetails);
}
}
if (config.allOf) {
config.allOf.forEach(processConfig);
}
};
configurations.forEach(processConfig);
const result: IConfigurationExport = {
settings: settings.sort((a, b) => a.name.localeCompare(b.name)),
buildTime: Date.now(),
commit: product.commit,
buildNumber: product.settingsSearchBuildId
};
return result;
}
}

3
src/vs/workbench/services/configuration/node/jsonEditingService.ts
View File

@@ -42,7 +42,8 @@ export class JSONEditingService implements IJSONEditingService {
private doWriteConfiguration(resource: URI, value: IJSONValue, save: boolean): TPromise<void> {
return this.resolveAndValidate(resource, save)
.then(reference => this.writeToBuffer(reference.object.textEditorModel, value));
.then(reference => this.writeToBuffer(reference.object.textEditorModel, value)
.then(() => reference.dispose()));
}
private writeToBuffer(model: editorCommon.IModel, value: IJSONValue): TPromise<any> {