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

* Initial port of release/0.24 source code

* Fix additional headers

* Fix a typo in launch.json

src/vs/platform/configuration/test/common/configuration.test.ts

@@ -5,29 +5,10 @@
 'use strict';
 
 import * as assert from 'assert';
-import { ConfigurationModel, merge } from 'vs/platform/configuration/common/configuration';
-import { Extensions, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry';
-import { Registry } from 'vs/platform/registry/common/platform';
+import { merge, removeFromValueTree } from 'vs/platform/configuration/common/configuration';
 
 suite('Configuration', () => {
 
-	suiteSetup(() => {
-		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
-			'id': 'a',
-			'order': 1,
-			'title': 'a',
-			'type': 'object',
-			'properties': {
-				'a': {
-					'description': 'a',
-					'type': 'boolean',
-					'default': true,
-					'overridable': true
-				}
-			}
-		});
-	});
-
 	test('simple merge', () => {
 		let base = { 'a': 1, 'b': 2 };
 		merge(base, { 'a': 3, 'c': 4 }, true);
@@ -37,43 +18,92 @@ suite('Configuration', () => {
 		assert.deepEqual(base, { 'a': 1, 'b': 2, 'c': 4 });
 	});
 
-	test('Recursive merge', () => {
-		const base = { 'a': { 'b': 1 } };
-		merge(base, { 'a': { 'b': 2 } }, true);
-		assert.deepEqual(base, { 'a': { 'b': 2 } });
+	test('removeFromValueTree: remove a non existing key', () => {
+		let target = { 'a': { 'b': 2 } };
+
+		removeFromValueTree(target, 'c');
+
+		assert.deepEqual(target, { 'a': { 'b': 2 } });
 	});
 
-	test('simple merge using configuration', () => {
-		let base = new ConfigurationModel<any>({ 'a': 1, 'b': 2 });
-		let add = new ConfigurationModel<any>({ 'a': 3, 'c': 4 });
-		let result = base.merge(add);
-		assert.deepEqual(result.contents, { 'a': 3, 'b': 2, 'c': 4 });
+	test('removeFromValueTree: remove a multi segmented key from an object that has only sub sections of the key', () => {
+		let target = { 'a': { 'b': 2 } };
+
+		removeFromValueTree(target, 'a.b.c');
+
+		assert.deepEqual(target, { 'a': { 'b': 2 } });
 	});
 
-	test('Recursive merge using config models', () => {
-		let base = new ConfigurationModel({ 'a': { 'b': 1 } });
-		let add = new ConfigurationModel({ 'a': { 'b': 2 } });
-		let result = base.merge(add);
-		assert.deepEqual(result.contents, { 'a': { 'b': 2 } });
+	test('removeFromValueTree: remove a single segemented key', () => {
+		let target = { 'a': 1 };
+
+		removeFromValueTree(target, 'a');
+
+		assert.deepEqual(target, {});
 	});
 
-	test('Test contents while getting an existing property', () => {
-		let testObject = new ConfigurationModel({ 'a': 1 });
-		assert.deepEqual(testObject.getContentsFor('a'), 1);
+	test('removeFromValueTree: remove a single segemented key when its value is undefined', () => {
+		let target = { 'a': void 0 };
 
-		testObject = new ConfigurationModel<any>({ 'a': { 'b': 1 } });
-		assert.deepEqual(testObject.getContentsFor('a'), { 'b': 1 });
+		removeFromValueTree(target, 'a');
+
+		assert.deepEqual(target, {});
 	});
 
-	test('Test contents are undefined for non existing properties', () => {
-		const testObject = new ConfigurationModel({ awesome: true });
+	test('removeFromValueTree: remove a multi segemented key when its value is undefined', () => {
+		let target = { 'a': { 'b': 1 } };
 
-		assert.deepEqual(testObject.getContentsFor('unknownproperty'), undefined);
+		removeFromValueTree(target, 'a.b');
+
+		assert.deepEqual(target, {});
 	});
 
-	test('Test override gives all content merged with overrides', () => {
-		const testObject = new ConfigurationModel<any>({ 'a': 1, 'c': 1 }, [], [{ identifiers: ['b'], contents: { 'a': 2 } }]);
+	test('removeFromValueTree: remove a multi segemented key when its value is array', () => {
+		let target = { 'a': { 'b': [1] } };
 
-		assert.deepEqual(testObject.override('b').contents, { 'a': 2, 'c': 1 });
+		removeFromValueTree(target, 'a.b');
+
+		assert.deepEqual(target, {});
 	});
+
+	test('removeFromValueTree: remove a multi segemented key first segment value is array', () => {
+		let target = { 'a': [1] };
+
+		removeFromValueTree(target, 'a.0');
+
+		assert.deepEqual(target, { 'a': [1] });
+	});
+
+	test('removeFromValueTree: remove when key is the first segmenet', () => {
+		let target = { 'a': { 'b': 1 } };
+
+		removeFromValueTree(target, 'a');
+
+		assert.deepEqual(target, {});
+	});
+
+	test('removeFromValueTree: remove a multi segemented key when the first node has more values', () => {
+		let target = { 'a': { 'b': { 'c': 1 }, 'd': 1 } };
+
+		removeFromValueTree(target, 'a.b.c');
+
+		assert.deepEqual(target, { 'a': { 'd': 1 } });
+	});
+
+	test('removeFromValueTree: remove a multi segemented key when in between node has more values', () => {
+		let target = { 'a': { 'b': { 'c': { 'd': 1 }, 'd': 1 } } };
+
+		removeFromValueTree(target, 'a.b.c.d');
+
+		assert.deepEqual(target, { 'a': { 'b': { 'd': 1 } } });
+	});
+
+	test('removeFromValueTree: remove a multi segemented key when the last but one node has more values', () => {
+		let target = { 'a': { 'b': { 'c': 1, 'd': 1 } } };
+
+		removeFromValueTree(target, 'a.b.c');
+
+		assert.deepEqual(target, { 'a': { 'b': { 'd': 1 } } });
+	});
+
 });

src/vs/platform/configuration/test/common/configurationModels.test.ts

@@ -0,0 +1,550 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 * as assert from 'assert';
+import { ConfigurationModel, CustomConfigurationModel, DefaultConfigurationModel, ConfigurationChangeEvent, AllKeysConfigurationChangeEvent } from 'vs/platform/configuration/common/configurationModels';
+import { Extensions, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry';
+import { Registry } from 'vs/platform/registry/common/platform';
+import URI from 'vs/base/common/uri';
+import { ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
+
+suite('ConfigurationModel', () => {
+
+	test('setValue for a key that has no sections and not defined', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 1 } }, ['a.b']);
+
+		testObject.setValue('f', 1);
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': 1 }, 'f': 1 });
+		assert.deepEqual(testObject.keys, ['a.b', 'f']);
+	});
+
+	test('setValue for a key that has no sections and defined', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 1 }, 'f': 1 }, ['a.b', 'f']);
+
+		testObject.setValue('f', 3);
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': 1 }, 'f': 3 });
+		assert.deepEqual(testObject.keys, ['a.b', 'f']);
+	});
+
+	test('setValue for a key that has sections and not defined', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 1 }, 'f': 1 }, ['a.b', 'f']);
+
+		testObject.setValue('b.c', 1);
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': 1 }, 'b': { 'c': 1 }, 'f': 1 });
+		assert.deepEqual(testObject.keys, ['a.b', 'f', 'b.c']);
+	});
+
+	test('setValue for a key that has sections and defined', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 1 }, 'b': { 'c': 1 }, 'f': 1 }, ['a.b', 'b.c', 'f']);
+
+		testObject.setValue('b.c', 3);
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': 1 }, 'b': { 'c': 3 }, 'f': 1 });
+		assert.deepEqual(testObject.keys, ['a.b', 'b.c', 'f']);
+	});
+
+	test('setValue for a key that has sections and sub section not defined', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 1 }, 'f': 1 }, ['a.b', 'f']);
+
+		testObject.setValue('a.c', 1);
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': 1, 'c': 1 }, 'f': 1 });
+		assert.deepEqual(testObject.keys, ['a.b', 'f', 'a.c']);
+	});
+
+	test('setValue for a key that has sections and sub section defined', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 1, 'c': 1 }, 'f': 1 }, ['a.b', 'a.c', 'f']);
+
+		testObject.setValue('a.c', 3);
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': 1, 'c': 3 }, 'f': 1 });
+		assert.deepEqual(testObject.keys, ['a.b', 'a.c', 'f']);
+	});
+
+	test('setValue for a key that has sections and last section is added', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': {} }, 'f': 1 }, ['a.b', 'f']);
+
+		testObject.setValue('a.b.c', 1);
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': { 'c': 1 } }, 'f': 1 });
+		assert.deepEqual(testObject.keys, ['a.b.c', 'f']);
+	});
+
+	test('removeValue: remove a non existing key', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 2 } }, ['a.b']);
+
+		testObject.removeValue('a.b.c');
+
+		assert.deepEqual(testObject.contents, { 'a': { 'b': 2 } });
+		assert.deepEqual(testObject.keys, ['a.b']);
+	});
+
+	test('removeValue: remove a single segemented key', () => {
+		let testObject = new ConfigurationModel({ 'a': 1 }, ['a']);
+
+		testObject.removeValue('a');
+
+		assert.deepEqual(testObject.contents, {});
+		assert.deepEqual(testObject.keys, []);
+	});
+
+	test('removeValue: remove a multi segemented key', () => {
+		let testObject = new ConfigurationModel({ 'a': { 'b': 1 } }, ['a.b']);
+
+		testObject.removeValue('a.b');
+
+		assert.deepEqual(testObject.contents, {});
+		assert.deepEqual(testObject.keys, []);
+	});
+
+	test('setValueInOverrides adds to overrides if does not exist', () => {
+		let testObject = new ConfigurationModel({ 'a': 1, 'b': 1 }, ['a']);
+
+		testObject.setValueInOverrides('or', 'a', 2);
+
+		assert.deepEqual(testObject.overrides[0].contents, { 'a': 2 });
+		assert.deepEqual(testObject.override('or').contents, { 'a': 2, 'b': 1 });
+	});
+
+	test('setValueInOverrides adds to overrides if exist', () => {
+		let testObject = new ConfigurationModel({ 'a': 1, 'b': 1 }, ['a'], [{ identifiers: ['or'], contents: { 'a': 2 } }]);
+
+		testObject.setValueInOverrides('or', 'a', 3);
+
+		assert.deepEqual(testObject.overrides[0].contents, { 'a': 3 });
+		assert.deepEqual(testObject.override('or').contents, { 'a': 3, 'b': 1 });
+	});
+
+	test('setValueInOverrides adds a nested key to overrides if exist', () => {
+		let testObject = new ConfigurationModel({ 'a': 1, 'b': 1 }, ['a'], [{ identifiers: ['or'], contents: { 'a': { 'c': 1 } } }]);
+
+		testObject.setValueInOverrides('or', 'a.c', 2);
+
+		assert.deepEqual(testObject.overrides[0].contents, { 'a': { 'c': 2 } });
+		assert.deepEqual(testObject.override('or').contents, { 'a': { 'c': 2 }, 'b': 1 });
+	});
+
+	test('setValueInOverrides adds new overrides if exist', () => {
+		let testObject = new ConfigurationModel({ 'a': 1, 'b': 1 }, ['a'], [{ identifiers: ['or1'], contents: { 'a': 2 } }]);
+
+		testObject.setValueInOverrides('or2', 'b', 2);
+
+		assert.deepEqual(testObject.overrides[0].contents, { 'a': 2 });
+		assert.deepEqual(testObject.overrides[1].contents, { 'b': 2 });
+		assert.deepEqual(testObject.override('or1').contents, { 'a': 2, 'b': 1 });
+		assert.deepEqual(testObject.override('or2').contents, { 'a': 1, 'b': 2 });
+	});
+
+	test('get overriding configuration model for an existing identifier', () => {
+		let testObject = new ConfigurationModel(
+			{ 'a': { 'b': 1 }, 'f': 1 }, [],
+			[{ identifiers: ['c'], contents: { 'a': { 'd': 1 } } }]);
+
+		assert.deepEqual(testObject.override('c').contents, { 'a': { 'b': 1, 'd': 1 }, 'f': 1 });
+	});
+
+	test('get overriding configuration model for an identifier that does not exist', () => {
+		let testObject = new ConfigurationModel(
+			{ 'a': { 'b': 1 }, 'f': 1 }, [],
+			[{ identifiers: ['c'], contents: { 'a': { 'd': 1 } } }]);
+
+		assert.deepEqual(testObject.override('xyz').contents, { 'a': { 'b': 1 }, 'f': 1 });
+	});
+
+	test('get overriding configuration when one of the keys does not exist in base', () => {
+		let testObject = new ConfigurationModel(
+			{ 'a': { 'b': 1 }, 'f': 1 }, [],
+			[{ identifiers: ['c'], contents: { 'a': { 'd': 1 }, 'g': 1 } }]);
+
+		assert.deepEqual(testObject.override('c').contents, { 'a': { 'b': 1, 'd': 1 }, 'f': 1, 'g': 1 });
+	});
+
+	test('get overriding configuration when one of the key in base is not of object type', () => {
+		let testObject = new ConfigurationModel(
+			{ 'a': { 'b': 1 }, 'f': 1 }, [],
+			[{ identifiers: ['c'], contents: { 'a': { 'd': 1 }, 'f': { 'g': 1 } } }]);
+
+		assert.deepEqual(testObject.override('c').contents, { 'a': { 'b': 1, 'd': 1 }, 'f': { 'g': 1 } });
+	});
+
+	test('get overriding configuration when one of the key in overriding contents is not of object type', () => {
+		let testObject = new ConfigurationModel(
+			{ 'a': { 'b': 1 }, 'f': { 'g': 1 } }, [],
+			[{ identifiers: ['c'], contents: { 'a': { 'd': 1 }, 'f': 1 } }]);
+
+		assert.deepEqual(testObject.override('c').contents, { 'a': { 'b': 1, 'd': 1 }, 'f': 1 });
+	});
+
+	test('get overriding configuration if the value of overriding identifier is not object', () => {
+		let testObject = new ConfigurationModel(
+			{ 'a': { 'b': 1 }, 'f': { 'g': 1 } }, [],
+			[{ identifiers: ['c'], contents: 'abc' }]);
+
+		assert.deepEqual(testObject.override('c').contents, { 'a': { 'b': 1 }, 'f': { 'g': 1 } });
+	});
+
+	test('get overriding configuration if the value of overriding identifier is an empty object', () => {
+		let testObject = new ConfigurationModel(
+			{ 'a': { 'b': 1 }, 'f': { 'g': 1 } }, [],
+			[{ identifiers: ['c'], contents: {} }]);
+
+		assert.deepEqual(testObject.override('c').contents, { 'a': { 'b': 1 }, 'f': { 'g': 1 } });
+	});
+
+	test('simple merge', () => {
+		let base = new ConfigurationModel({ 'a': 1, 'b': 2 }, ['a', 'b']);
+		let add = new ConfigurationModel({ 'a': 3, 'c': 4 }, ['a', 'c']);
+		let result = base.merge(add);
+
+		assert.deepEqual(result.contents, { 'a': 3, 'b': 2, 'c': 4 });
+		assert.deepEqual(result.keys, ['a', 'b', 'c']);
+	});
+
+	test('recursive merge', () => {
+		let base = new ConfigurationModel({ 'a': { 'b': 1 } }, ['a.b']);
+		let add = new ConfigurationModel({ 'a': { 'b': 2 } }, ['a.b']);
+		let result = base.merge(add);
+
+		assert.deepEqual(result.contents, { 'a': { 'b': 2 } });
+		assert.deepEqual(result.getSectionContents('a'), { 'b': 2 });
+		assert.deepEqual(result.keys, ['a.b']);
+	});
+
+	test('simple merge overrides', () => {
+		let base = new ConfigurationModel({ 'a': { 'b': 1 } }, ['a.b'], [{ identifiers: ['c'], contents: { 'a': 2 } }]);
+		let add = new ConfigurationModel({ 'a': { 'b': 2 } }, ['a.b'], [{ identifiers: ['c'], contents: { 'b': 2 } }]);
+		let result = base.merge(add);
+
+		assert.deepEqual(result.contents, { 'a': { 'b': 2 } });
+		assert.deepEqual(result.overrides, [{ identifiers: ['c'], contents: { 'a': 2, 'b': 2 } }]);
+		assert.deepEqual(result.override('c').contents, { 'a': 2, 'b': 2 });
+		assert.deepEqual(result.keys, ['a.b']);
+	});
+
+	test('recursive merge overrides', () => {
+		let base = new ConfigurationModel({ 'a': { 'b': 1 }, 'f': 1 }, ['a.b', 'f'], [{ identifiers: ['c'], contents: { 'a': { 'd': 1 } } }]);
+		let add = new ConfigurationModel({ 'a': { 'b': 2 } }, ['a.b'], [{ identifiers: ['c'], contents: { 'a': { 'e': 2 } } }]);
+		let result = base.merge(add);
+
+		assert.deepEqual(result.contents, { 'a': { 'b': 2 }, 'f': 1 });
+		assert.deepEqual(result.overrides, [{ identifiers: ['c'], contents: { 'a': { 'd': 1, 'e': 2 } } }]);
+		assert.deepEqual(result.override('c').contents, { 'a': { 'b': 2, 'd': 1, 'e': 2 }, 'f': 1 });
+		assert.deepEqual(result.keys, ['a.b', 'f']);
+	});
+
+	test('Test contents while getting an existing property', () => {
+		let testObject = new ConfigurationModel({ 'a': 1 });
+		assert.deepEqual(testObject.getSectionContents('a'), 1);
+
+		testObject = new ConfigurationModel({ 'a': { 'b': 1 } });
+		assert.deepEqual(testObject.getSectionContents('a'), { 'b': 1 });
+	});
+
+	test('Test contents are undefined for non existing properties', () => {
+		const testObject = new ConfigurationModel({ awesome: true });
+
+		assert.deepEqual(testObject.getSectionContents('unknownproperty'), undefined);
+	});
+
+	test('Test override gives all content merged with overrides', () => {
+		const testObject = new ConfigurationModel({ 'a': 1, 'c': 1 }, [], [{ identifiers: ['b'], contents: { 'a': 2 } }]);
+
+		assert.deepEqual(testObject.override('b').contents, { 'a': 2, 'c': 1 });
+	});
+});
+
+suite('CustomConfigurationModel', () => {
+
+	suiteSetup(() => {
+		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
+			'id': 'a',
+			'order': 1,
+			'title': 'a',
+			'type': 'object',
+			'properties': {
+				'a': {
+					'description': 'a',
+					'type': 'boolean',
+					'default': true,
+					'overridable': true
+				}
+			}
+		});
+	});
+
+	test('simple merge using models', () => {
+		let base = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'b': 2 }));
+		let add = new CustomConfigurationModel(JSON.stringify({ 'a': 3, 'c': 4 }));
+		let result = base.merge(add);
+		assert.deepEqual(result.contents, { 'a': 3, 'b': 2, 'c': 4 });
+	});
+
+	test('simple merge with an undefined contents', () => {
+		let base = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'b': 2 }));
+		let add = new CustomConfigurationModel(null);
+		let result = base.merge(add);
+		assert.deepEqual(result.contents, { 'a': 1, 'b': 2 });
+
+		base = new CustomConfigurationModel(null);
+		add = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'b': 2 }));
+		result = base.merge(add);
+		assert.deepEqual(result.contents, { 'a': 1, 'b': 2 });
+
+		base = new CustomConfigurationModel(null);
+		add = new CustomConfigurationModel(null);
+		result = base.merge(add);
+		assert.deepEqual(result.contents, {});
+	});
+
+	test('Recursive merge using config models', () => {
+		let base = new CustomConfigurationModel(JSON.stringify({ 'a': { 'b': 1 } }));
+		let add = new CustomConfigurationModel(JSON.stringify({ 'a': { 'b': 2 } }));
+		let result = base.merge(add);
+		assert.deepEqual(result.contents, { 'a': { 'b': 2 } });
+	});
+
+	test('Test contents while getting an existing property', () => {
+		let testObject = new CustomConfigurationModel(JSON.stringify({ 'a': 1 }));
+		assert.deepEqual(testObject.getSectionContents('a'), 1);
+
+		testObject = new CustomConfigurationModel(JSON.stringify({ 'a': { 'b': 1 } }));
+		assert.deepEqual(testObject.getSectionContents('a'), { 'b': 1 });
+	});
+
+	test('Test contents are undefined for non existing properties', () => {
+		const testObject = new CustomConfigurationModel(JSON.stringify({
+			awesome: true
+		}));
+
+		assert.deepEqual(testObject.getSectionContents('unknownproperty'), undefined);
+	});
+
+	test('Test contents are undefined for undefined config', () => {
+		const testObject = new CustomConfigurationModel(null);
+
+		assert.deepEqual(testObject.getSectionContents('unknownproperty'), undefined);
+	});
+
+	test('Test configWithOverrides gives all content merged with overrides', () => {
+		const testObject = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'c': 1, '[b]': { 'a': 2 } }));
+
+		assert.deepEqual(testObject.override('b').contents, { 'a': 2, 'c': 1, '[b]': { 'a': 2 } });
+	});
+
+	test('Test configWithOverrides gives empty contents', () => {
+		const testObject = new CustomConfigurationModel(null);
+
+		assert.deepEqual(testObject.override('b').contents, {});
+	});
+
+	test('Test update with empty data', () => {
+		const testObject = new CustomConfigurationModel();
+		testObject.update('');
+
+		assert.deepEqual(testObject.contents, {});
+		assert.deepEqual(testObject.keys, []);
+
+		testObject.update(null);
+
+		assert.deepEqual(testObject.contents, {});
+		assert.deepEqual(testObject.keys, []);
+
+		testObject.update(undefined);
+
+		assert.deepEqual(testObject.contents, {});
+		assert.deepEqual(testObject.keys, []);
+	});
+
+	test('Test registering the same property again', () => {
+		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
+			'id': 'a',
+			'order': 1,
+			'title': 'a',
+			'type': 'object',
+			'properties': {
+				'a': {
+					'description': 'a',
+					'type': 'boolean',
+					'default': false,
+				}
+			}
+		});
+		assert.equal(true, new DefaultConfigurationModel().getSectionContents('a'));
+	});
+
+	test('Test registering the language property', () => {
+		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
+			'id': '[a]',
+			'order': 1,
+			'title': 'a',
+			'type': 'object',
+			'properties': {
+				'[a]': {
+					'description': 'a',
+					'type': 'boolean',
+					'default': false,
+				}
+			}
+		});
+		assert.equal(undefined, new DefaultConfigurationModel().getSectionContents('[a]'));
+	});
+
+});
+
+suite('ConfigurationChangeEvent', () => {
+
+	test('changeEvent affecting keys for all resources', () => {
+		let testObject = new ConfigurationChangeEvent();
+
+		testObject.change(['window.zoomLevel', 'workbench.editor.enablePreview', 'files', '[markdown]']);
+
+		assert.deepEqual(testObject.affectedKeys, ['window.zoomLevel', 'workbench.editor.enablePreview', 'files', '[markdown]']);
+		assert.ok(testObject.affectsConfiguration('window.zoomLevel'));
+		assert.ok(testObject.affectsConfiguration('window'));
+		assert.ok(testObject.affectsConfiguration('workbench.editor.enablePreview'));
+		assert.ok(testObject.affectsConfiguration('workbench.editor'));
+		assert.ok(testObject.affectsConfiguration('workbench'));
+		assert.ok(testObject.affectsConfiguration('files'));
+		assert.ok(!testObject.affectsConfiguration('files.exclude'));
+		assert.ok(testObject.affectsConfiguration('[markdown]'));
+	});
+
+	test('changeEvent affecting a root key and its children', () => {
+		let testObject = new ConfigurationChangeEvent();
+
+		testObject.change(['launch', 'launch.version', 'tasks']);
+
+		assert.deepEqual(testObject.affectedKeys, ['launch.version', 'tasks']);
+		assert.ok(testObject.affectsConfiguration('launch'));
+		assert.ok(testObject.affectsConfiguration('launch.version'));
+		assert.ok(testObject.affectsConfiguration('tasks'));
+	});
+
+	test('changeEvent affecting keys for resources', () => {
+		let testObject = new ConfigurationChangeEvent();
+
+		testObject.change(['window.title']);
+		testObject.change(['window.zoomLevel'], URI.file('file1'));
+		testObject.change(['workbench.editor.enablePreview'], URI.file('file2'));
+		testObject.change(['window.restoreFullscreen'], URI.file('file1'));
+		testObject.change(['window.restoreWindows'], URI.file('file2'));
+
+		assert.deepEqual(testObject.affectedKeys, ['window.title', 'window.zoomLevel', 'window.restoreFullscreen', 'workbench.editor.enablePreview', 'window.restoreWindows']);
+
+		assert.ok(testObject.affectsConfiguration('window.zoomLevel'));
+		assert.ok(testObject.affectsConfiguration('window.zoomLevel', URI.file('file1')));
+		assert.ok(!testObject.affectsConfiguration('window.zoomLevel', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('window.restoreFullscreen'));
+		assert.ok(testObject.affectsConfiguration('window.restoreFullscreen', URI.file('file1')));
+		assert.ok(!testObject.affectsConfiguration('window.restoreFullscreen', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('window.restoreWindows'));
+		assert.ok(testObject.affectsConfiguration('window.restoreWindows', URI.file('file2')));
+		assert.ok(!testObject.affectsConfiguration('window.restoreWindows', URI.file('file1')));
+
+		assert.ok(testObject.affectsConfiguration('window.title'));
+		assert.ok(testObject.affectsConfiguration('window.title', URI.file('file1')));
+		assert.ok(testObject.affectsConfiguration('window.title', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('window'));
+		assert.ok(testObject.affectsConfiguration('window', URI.file('file1')));
+		assert.ok(testObject.affectsConfiguration('window', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('workbench.editor.enablePreview'));
+		assert.ok(testObject.affectsConfiguration('workbench.editor.enablePreview', URI.file('file2')));
+		assert.ok(!testObject.affectsConfiguration('workbench.editor.enablePreview', URI.file('file1')));
+
+		assert.ok(testObject.affectsConfiguration('workbench.editor'));
+		assert.ok(testObject.affectsConfiguration('workbench.editor', URI.file('file2')));
+		assert.ok(!testObject.affectsConfiguration('workbench.editor', URI.file('file1')));
+
+		assert.ok(testObject.affectsConfiguration('workbench'));
+		assert.ok(testObject.affectsConfiguration('workbench', URI.file('file2')));
+		assert.ok(!testObject.affectsConfiguration('workbench', URI.file('file1')));
+
+		assert.ok(!testObject.affectsConfiguration('files'));
+		assert.ok(!testObject.affectsConfiguration('files', URI.file('file1')));
+		assert.ok(!testObject.affectsConfiguration('files', URI.file('file2')));
+	});
+
+	test('merging change events', () => {
+		let event1 = new ConfigurationChangeEvent().change(['window.zoomLevel', 'files']);
+		let event2 = new ConfigurationChangeEvent().change(['window.title'], URI.file('file1')).change(['[markdown]']);
+
+		let actual = event1.change(event2);
+
+		assert.deepEqual(actual.affectedKeys, ['window.zoomLevel', 'files', '[markdown]', 'window.title']);
+
+		assert.ok(actual.affectsConfiguration('window.zoomLevel'));
+		assert.ok(actual.affectsConfiguration('window.zoomLevel', URI.file('file1')));
+		assert.ok(actual.affectsConfiguration('window.zoomLevel', URI.file('file2')));
+
+		assert.ok(actual.affectsConfiguration('window'));
+		assert.ok(actual.affectsConfiguration('window', URI.file('file1')));
+		assert.ok(actual.affectsConfiguration('window', URI.file('file2')));
+
+		assert.ok(actual.affectsConfiguration('files'));
+		assert.ok(actual.affectsConfiguration('files', URI.file('file1')));
+		assert.ok(actual.affectsConfiguration('files', URI.file('file2')));
+
+		assert.ok(actual.affectsConfiguration('window.title'));
+		assert.ok(actual.affectsConfiguration('window.title', URI.file('file1')));
+		assert.ok(!actual.affectsConfiguration('window.title', URI.file('file2')));
+
+		assert.ok(actual.affectsConfiguration('[markdown]'));
+		assert.ok(actual.affectsConfiguration('[markdown]', URI.file('file1')));
+		assert.ok(actual.affectsConfiguration('[markdown]', URI.file('file2')));
+	});
+
+});
+
+suite('AllKeysConfigurationChangeEvent', () => {
+
+	test('changeEvent affects keys for any resource', () => {
+		let testObject = new AllKeysConfigurationChangeEvent(['window.title', 'window.zoomLevel', 'window.restoreFullscreen', 'workbench.editor.enablePreview', 'window.restoreWindows'], ConfigurationTarget.USER, null);
+
+		assert.deepEqual(testObject.affectedKeys, ['window.title', 'window.zoomLevel', 'window.restoreFullscreen', 'workbench.editor.enablePreview', 'window.restoreWindows']);
+
+		assert.ok(testObject.affectsConfiguration('window.zoomLevel'));
+		assert.ok(testObject.affectsConfiguration('window.zoomLevel', URI.file('file1')));
+		assert.ok(testObject.affectsConfiguration('window.zoomLevel', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('window.restoreFullscreen'));
+		assert.ok(testObject.affectsConfiguration('window.restoreFullscreen', URI.file('file1')));
+		assert.ok(testObject.affectsConfiguration('window.restoreFullscreen', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('window.restoreWindows'));
+		assert.ok(testObject.affectsConfiguration('window.restoreWindows', URI.file('file2')));
+		assert.ok(testObject.affectsConfiguration('window.restoreWindows', URI.file('file1')));
+
+		assert.ok(testObject.affectsConfiguration('window.title'));
+		assert.ok(testObject.affectsConfiguration('window.title', URI.file('file1')));
+		assert.ok(testObject.affectsConfiguration('window.title', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('window'));
+		assert.ok(testObject.affectsConfiguration('window', URI.file('file1')));
+		assert.ok(testObject.affectsConfiguration('window', URI.file('file2')));
+
+		assert.ok(testObject.affectsConfiguration('workbench.editor.enablePreview'));
+		assert.ok(testObject.affectsConfiguration('workbench.editor.enablePreview', URI.file('file2')));
+		assert.ok(testObject.affectsConfiguration('workbench.editor.enablePreview', URI.file('file1')));
+
+		assert.ok(testObject.affectsConfiguration('workbench.editor'));
+		assert.ok(testObject.affectsConfiguration('workbench.editor', URI.file('file2')));
+		assert.ok(testObject.affectsConfiguration('workbench.editor', URI.file('file1')));
+
+		assert.ok(testObject.affectsConfiguration('workbench'));
+		assert.ok(testObject.affectsConfiguration('workbench', URI.file('file2')));
+		assert.ok(testObject.affectsConfiguration('workbench', URI.file('file1')));
+
+		assert.ok(!testObject.affectsConfiguration('files'));
+		assert.ok(!testObject.affectsConfiguration('files', URI.file('file1')));
+	});
+});

src/vs/platform/configuration/test/common/model.test.ts

@@ -1,148 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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 * as assert from 'assert';
-import { CustomConfigurationModel, DefaultConfigurationModel } from 'vs/platform/configuration/common/model';
-import { Extensions, IConfigurationRegistry } from 'vs/platform/configuration/common/configurationRegistry';
-import { Registry } from 'vs/platform/registry/common/platform';
-
-suite('Configuration', () => {
-
-	suiteSetup(() => {
-		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
-			'id': 'a',
-			'order': 1,
-			'title': 'a',
-			'type': 'object',
-			'properties': {
-				'a': {
-					'description': 'a',
-					'type': 'boolean',
-					'default': true,
-					'overridable': true
-				}
-			}
-		});
-	});
-
-	test('simple merge using models', () => {
-		let base = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'b': 2 }));
-		let add = new CustomConfigurationModel(JSON.stringify({ 'a': 3, 'c': 4 }));
-		let result = base.merge(add);
-		assert.deepEqual(result.contents, { 'a': 3, 'b': 2, 'c': 4 });
-	});
-
-	test('simple merge with an undefined contents', () => {
-		let base = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'b': 2 }));
-		let add = new CustomConfigurationModel(null);
-		let result = base.merge(add);
-		assert.deepEqual(result.contents, { 'a': 1, 'b': 2 });
-
-		base = new CustomConfigurationModel(null);
-		add = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'b': 2 }));
-		result = base.merge(add);
-		assert.deepEqual(result.contents, { 'a': 1, 'b': 2 });
-
-		base = new CustomConfigurationModel(null);
-		add = new CustomConfigurationModel(null);
-		result = base.merge(add);
-		assert.deepEqual(result.contents, {});
-	});
-
-	test('Recursive merge using config models', () => {
-		let base = new CustomConfigurationModel(JSON.stringify({ 'a': { 'b': 1 } }));
-		let add = new CustomConfigurationModel(JSON.stringify({ 'a': { 'b': 2 } }));
-		let result = base.merge(add);
-		assert.deepEqual(result.contents, { 'a': { 'b': 2 } });
-	});
-
-	test('Test contents while getting an existing property', () => {
-		let testObject = new CustomConfigurationModel(JSON.stringify({ 'a': 1 }));
-		assert.deepEqual(testObject.getContentsFor('a'), 1);
-
-		testObject = new CustomConfigurationModel(JSON.stringify({ 'a': { 'b': 1 } }));
-		assert.deepEqual(testObject.getContentsFor('a'), { 'b': 1 });
-	});
-
-	test('Test contents are undefined for non existing properties', () => {
-		const testObject = new CustomConfigurationModel(JSON.stringify({
-			awesome: true
-		}));
-
-		assert.deepEqual(testObject.getContentsFor('unknownproperty'), undefined);
-	});
-
-	test('Test contents are undefined for undefined config', () => {
-		const testObject = new CustomConfigurationModel(null);
-
-		assert.deepEqual(testObject.getContentsFor('unknownproperty'), undefined);
-	});
-
-	test('Test configWithOverrides gives all content merged with overrides', () => {
-		const testObject = new CustomConfigurationModel(JSON.stringify({ 'a': 1, 'c': 1, '[b]': { 'a': 2 } }));
-
-		assert.deepEqual(testObject.override('b').contents, { 'a': 2, 'c': 1, '[b]': { 'a': 2 } });
-	});
-
-	test('Test configWithOverrides gives empty contents', () => {
-		const testObject = new CustomConfigurationModel(null);
-
-		assert.deepEqual(testObject.override('b').contents, {});
-	});
-
-	test('Test update with empty data', () => {
-		const testObject = new CustomConfigurationModel();
-		testObject.update('');
-
-		assert.deepEqual(testObject.contents, {});
-		assert.deepEqual(testObject.keys, []);
-
-		testObject.update(null);
-
-		assert.deepEqual(testObject.contents, {});
-		assert.deepEqual(testObject.keys, []);
-
-		testObject.update(undefined);
-
-		assert.deepEqual(testObject.contents, {});
-		assert.deepEqual(testObject.keys, []);
-	});
-
-	test('Test registering the same property again', () => {
-		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
-			'id': 'a',
-			'order': 1,
-			'title': 'a',
-			'type': 'object',
-			'properties': {
-				'a': {
-					'description': 'a',
-					'type': 'boolean',
-					'default': false,
-				}
-			}
-		});
-		assert.equal(true, new DefaultConfigurationModel().getContentsFor('a'));
-	});
-
-	test('Test registering the language property', () => {
-		Registry.as<IConfigurationRegistry>(Extensions.Configuration).registerConfiguration({
-			'id': '[a]',
-			'order': 1,
-			'title': 'a',
-			'type': 'object',
-			'properties': {
-				'[a]': {
-					'description': 'a',
-					'type': 'boolean',
-					'default': false,
-				}
-			}
-		});
-		assert.equal(undefined, new DefaultConfigurationModel().getContentsFor('[a]'));
-	});
-
-});

src/vs/platform/configuration/test/common/testConfigurationService.ts

@@ -5,25 +5,25 @@
 
 'use strict';
 
-import { TrieMap } from 'vs/base/common/map';
+import { TernarySearchTree } from 'vs/base/common/map';
 import URI from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { EventEmitter } from 'vs/base/common/eventEmitter';
-import { getConfigurationKeys } from 'vs/platform/configuration/common/model';
-import { IConfigurationOverrides, IConfigurationService, getConfigurationValue, IConfigurationValue, IConfigurationKeys, IConfigurationValues, IConfigurationData, Configuration, ConfigurationModel } from 'vs/platform/configuration/common/configuration';
+import { getConfigurationKeys, IConfigurationOverrides, IConfigurationService, getConfigurationValue, isConfigurationOverrides } from 'vs/platform/configuration/common/configuration';
 
 export class TestConfigurationService extends EventEmitter implements IConfigurationService {
 	public _serviceBrand: any;
 
 	private configuration = Object.create(null);
 
-	private configurationByRoot: TrieMap<any> = new TrieMap<any>();
+	private configurationByRoot: TernarySearchTree<any> = TernarySearchTree.forPaths<any>();
 
-	public reloadConfiguration<T>(section?: string): TPromise<T> {
+	public reloadConfiguration<T>(): TPromise<T> {
 		return TPromise.as(this.getConfiguration());
 	}
 
-	public getConfiguration(section?: string, overrides?: IConfigurationOverrides): any {
+	public getConfiguration<C>(arg1?: any, arg2?: any): C {
+		const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : void 0;
 		if (overrides && overrides.resource) {
 			const configForResource = this.configurationByRoot.findSubstr(overrides.resource.fsPath);
 			return configForResource || this.configuration;
@@ -32,15 +32,19 @@ export class TestConfigurationService extends EventEmitter implements IConfigura
 		return this.configuration;
 	}
 
-	public getConfigurationData(): IConfigurationData<any> {
-		return new Configuration(new ConfigurationModel(), new ConfigurationModel(this.configuration)).toData();
+	public getValue(key: string, overrides?: IConfigurationOverrides): any {
+		return this.inspect(key).value;
+	}
+
+	public updateValue(key: string, overrides?: IConfigurationOverrides): TPromise<void> {
+		return TPromise.as(null);
 	}
 
 	public setUserConfiguration(key: any, value: any, root?: URI): Thenable<void> {
 		if (root) {
-			const configForRoot = this.configurationByRoot.lookUp(root.fsPath) || Object.create(null);
+			const configForRoot = this.configurationByRoot.get(root.fsPath) || Object.create(null);
 			configForRoot[key] = value;
-			this.configurationByRoot.insert(root.fsPath, configForRoot);
+			this.configurationByRoot.set(root.fsPath, configForRoot);
 		} else {
 			this.configuration[key] = value;
 		}
@@ -48,32 +52,38 @@ export class TestConfigurationService extends EventEmitter implements IConfigura
 		return TPromise.as(null);
 	}
 
-	public onDidUpdateConfiguration() {
+	public onDidChangeConfiguration() {
 		return { dispose() { } };
 	}
 
-	public lookup<C>(key: string, overrides?: IConfigurationOverrides): IConfigurationValue<C> {
+	public inspect<T>(key: string, overrides?: IConfigurationOverrides): {
+		default: T,
+		user: T,
+		workspace: T,
+		workspaceFolder: T
+		value: T,
+	} {
 		const config = this.getConfiguration(undefined, overrides);
 
 		return {
-			value: getConfigurationValue<C>(config, key),
-			default: getConfigurationValue<C>(config, key),
-			user: getConfigurationValue<C>(config, key),
+			value: getConfigurationValue<T>(config, key),
+			default: getConfigurationValue<T>(config, key),
+			user: getConfigurationValue<T>(config, key),
 			workspace: null,
-			folder: null
+			workspaceFolder: null
 		};
 	}
 
-	public keys(): IConfigurationKeys {
+	public keys() {
 		return {
 			default: getConfigurationKeys(),
 			user: Object.keys(this.configuration),
 			workspace: [],
-			folder: []
+			workspaceFolder: []
 		};
 	}
 
-	public values(): IConfigurationValues {
-		return {};
+	public getConfigurationData() {
+		return null;
 	}
 }

src/vs/platform/configuration/test/node/configurationService.test.ts

@@ -122,7 +122,8 @@ suite('ConfigurationService - Node', () => {
 			assert.equal(config.foo, 'bar');
 
 			// force a reload to get latest
-			service.reloadConfiguration<{ foo: string }>().then(config => {
+			service.reloadConfiguration().then(() => {
+				config = service.getConfiguration<{ foo: string }>();
 				assert.ok(config);
 				assert.equal(config.foo, 'changed');
 
@@ -202,12 +203,12 @@ suite('ConfigurationService - Node', () => {
 		testFile((testFile, cleanUp) => {
 			const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
 
-			let res = service.lookup('something.missing');
+			let res = service.inspect('something.missing');
 			assert.strictEqual(res.value, void 0);
 			assert.strictEqual(res.default, void 0);
 			assert.strictEqual(res.user, void 0);
 
-			res = service.lookup('lookup.service.testSetting');
+			res = service.inspect('lookup.service.testSetting');
 			assert.strictEqual(res.default, 'isSet');
 			assert.strictEqual(res.value, 'isSet');
 			assert.strictEqual(res.user, void 0);
@@ -215,7 +216,7 @@ suite('ConfigurationService - Node', () => {
 			fs.writeFileSync(testFile, '{ "lookup.service.testSetting": "bar" }');
 
 			return service.reloadConfiguration().then(() => {
-				res = service.lookup('lookup.service.testSetting');
+				res = service.inspect('lookup.service.testSetting');
 				assert.strictEqual(res.default, 'isSet');
 				assert.strictEqual(res.user, 'bar');
 				assert.strictEqual(res.value, 'bar');
@@ -242,7 +243,7 @@ suite('ConfigurationService - Node', () => {
 		testFile((testFile, cleanUp) => {
 			const service = new ConfigurationService(new SettingsTestEnvironmentService(parseArgs(process.argv), process.execPath, testFile));
 
-			let res = service.lookup('lookup.service.testNullSetting');
+			let res = service.inspect('lookup.service.testNullSetting');
 			assert.strictEqual(res.default, null);
 			assert.strictEqual(res.value, null);
 			assert.strictEqual(res.user, void 0);
@@ -250,7 +251,7 @@ suite('ConfigurationService - Node', () => {
 			fs.writeFileSync(testFile, '{ "lookup.service.testNullSetting": null }');
 
 			return service.reloadConfiguration().then(() => {
-				res = service.lookup('lookup.service.testNullSetting');
+				res = service.inspect('lookup.service.testNullSetting');
 				assert.strictEqual(res.default, null);
 				assert.strictEqual(res.value, null);
 				assert.strictEqual(res.user, null);