NodeConfigurationService

src/vs/platform/configuration/node/nodeConfigurationService.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { watch, FSWatcher, readFileSync } from 'fs';
+import * as path from 'path';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { Delayer } from 'vs/base/common/async';
+import * as json from 'vs/base/common/json';
+import { IDisposable, dispose, toDisposable } from 'vs/base/common/lifecycle';
+import { IConfigurationService, IConfigurationServiceEvent } from 'vs/platform/configuration/common/configuration';
+import Event, {Emitter} from 'vs/base/common/event';
+import { IEnvironmentService } from 'vs/platform/environment/common/environment';
+
+/**
+ * Configuration service to be used in the node side.
+ * TODO@Joao:
+ * 	- defaults handling
+ *  - async reading
+ *
+ * At some point, an async get() on the configuration service would be
+ * much easier to implement and reason about. IConfigurationService2?
+ */
+export class NodeConfigurationService implements IConfigurationService, IDisposable {
+
+	serviceId = IConfigurationService;
+
+	private configurationPath: string;
+	private watcher: FSWatcher;
+	private cache: any;
+	private delayer: Delayer<void>;
+	private disposables: IDisposable[];
+
+	private _onDidUpdateConfiguration = new Emitter<IConfigurationServiceEvent>();
+	get onDidUpdateConfiguration(): Event<IConfigurationServiceEvent> { return this._onDidUpdateConfiguration.event; }
+
+	constructor(
+		@IEnvironmentService environmentService: IEnvironmentService
+	) {
+		this.cache = {};
+		this.disposables = [];
+
+		this.delayer = new Delayer<void>(300);
+
+		// TODO@joao cleanup!
+		this.configurationPath = path.join(environmentService.userDataPath, 'User', 'settings.json');
+
+		// TODO@joao sync?
+		this.load();
+
+		this.watcher = watch(path.dirname(this.configurationPath));
+		this.disposables.push(toDisposable(() => {
+			this.watcher.removeAllListeners();
+			this.watcher.close();
+		}));
+
+		this.watcher.on('change', () => this.delayer.trigger(() => this.load()));
+	}
+
+	getConfiguration<T>(section?: string): T {
+		return this._getConfiguration<T>(section);
+	}
+
+	loadConfiguration<T>(section?: string): TPromise<T> {
+		return TPromise.wrapError(new Error('not implemented'));
+	}
+
+	private _getConfiguration<T>(section: string = ''): T {
+		let value = this.cache;
+
+		let parts = section
+			.split('.')
+			.filter(p => !!p);
+
+		while (parts.length && value) {
+			let part = parts.shift();
+			value = value[part];
+		}
+
+		return value;
+	}
+
+	private load(): void {
+		let content = '{}';
+
+		try {
+			// TODO@Joao: is sync really the way to go?
+			content = readFileSync(this.configurationPath, 'utf8');
+		} catch (error) {
+			content = '{}';
+		}
+
+		try {
+			this.cache = json.parse(content) || {};
+		} catch (error) {
+			// noop
+		}
+	}
+
+	hasWorkspaceConfiguration(): boolean {
+		return false;
+	}
+
+	dispose(): void {
+		this.disposables = dispose(this.disposables);
+	}
+}