Clean up IResourceService

src/vs/editor/common/services/resourceService.ts

@@ -4,47 +4,18 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {EmitterEvent, ListenerCallback} from 'vs/base/common/eventEmitter';
-import {IDisposable} from 'vs/base/common/lifecycle';
 import URI from 'vs/base/common/uri';
 import {createDecorator} from 'vs/platform/instantiation/common/instantiation';
 import {IMirrorModel} from 'vs/editor/common/editorCommon';
 
 // Resource Service
 
-export var ResourceEvents = {
-	ADDED: 'resource.added',
-	REMOVED: 'resource.removed',
-	CHANGED: 'resource.changed'
-};
-
-export interface IResourceAddedEvent {
-	url: URI;
-	addedElement: IMirrorModel;
-}
-
-export interface IResourceRemovedEvent {
-	url: URI;
-	removedElement: IMirrorModel;
-}
-
-export interface IResourceChangedEvent {
-	url: URI;
-	originalEvents: EmitterEvent[];
-}
-
-export var IResourceService = createDecorator<IResourceService>('resourceService');
+export let IResourceService = createDecorator<IResourceService>('resourceService');
 
 export interface IResourceService {
 	_serviceBrand: any;
+
 	insert(url: URI, element: IMirrorModel): void;
 	get(url: URI): IMirrorModel;
-	all(): IMirrorModel[];
-	contains(url: URI): boolean;
 	remove(url: URI): void;
-	addListener2_(eventType: 'resource.added', listener: (event: IResourceAddedEvent) => void): IDisposable;
-	addListener2_(eventType: 'resource.removed', listener: (event: IResourceRemovedEvent) => void): IDisposable;
-	addListener2_(eventType: 'resource.changed', listener: (event: IResourceChangedEvent) => void): IDisposable;
-	addListener2_(eventType: string, listener: ListenerCallback): IDisposable;
 }
-

src/vs/editor/common/services/resourceServiceImpl.ts

@@ -4,31 +4,48 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import {EventEmitter, EmitterEvent, ListenerCallback} from 'vs/base/common/eventEmitter';
-import {IDisposable, dispose} from 'vs/base/common/lifecycle';
 import URI from 'vs/base/common/uri';
 import {IMirrorModel} from 'vs/editor/common/editorCommon';
-import {IResourceAddedEvent, IResourceChangedEvent, IResourceRemovedEvent, IResourceService, ResourceEvents} from 'vs/editor/common/services/resourceService';
+import {IResourceService} from 'vs/editor/common/services/resourceService';
 
-export class ResourceService extends EventEmitter implements IResourceService {
-	public _serviceBrand: any;
-	private data:{[url:string]:IMirrorModel;};
-	private unbinds:{[url:string]:IDisposable[];};
+class MirrorModelMap {
+
+	private _data: {[key:string]:IMirrorModel};
 
 	constructor() {
-		super();
-		this.data = {};
-		this.unbinds = {};
+		this._data = {};
+	}
+
+	public set(key:string, data:IMirrorModel): void {
+		this._data[key] = data;
 	}
 
-	public addListener2_(eventType: string, listener: ListenerCallback): IDisposable {
-		return super.addListener2(eventType, listener);
+	public get(key:string): IMirrorModel {
+		return this._data[key] || null;
+	}
+
+	public contains(key:string): boolean {
+		return !!this._data[key];
+	}
+
+	public remove(key:string): void {
+		delete this._data[key];
+	}
+}
+
+export class ResourceService implements IResourceService {
+	public _serviceBrand: any;
+
+	private _map:MirrorModelMap;
+
+	constructor() {
+		this._map = new MirrorModelMap();
 	}
 
-	private _anonymousModelId(input:string): string {
-		var r = '';
-		for (var i = 0; i < input.length; i++) {
-			var ch = input[i];
+	private static _anonymousModelId(input:string): string {
+		let r = '';
+		for (let i = 0; i < input.length; i++) {
+			let ch = input[i];
 			if (ch >= '0' && ch <= '9') {
 				r += '0';
 				continue;
@@ -46,59 +63,25 @@ export class ResourceService extends EventEmitter implements IResourceService {
 		return r;
 	}
 
-	public insert(url:URI, element:IMirrorModel): void {
-		// console.log('INSERT: ' + url.toString());
-		if (this.contains(url)) {
-			// There already exists a model with this id => this is a programmer error
-			throw new Error('ResourceService: Cannot add model ' + this._anonymousModelId(url.toString()) + ' because it already exists!');
-		}
-
-		// add resource
-		var key = url.toString();
-		this.data[key] = element;
-		this.unbinds[key] = [];
-		this.unbinds[key].push(element.addBulkListener2((value:EmitterEvent[]) => {
-			this.emit(ResourceEvents.CHANGED, <IResourceChangedEvent>{ url: url, originalEvents: value });
-		}));
-
-		// event
-		this.emit(ResourceEvents.ADDED, <IResourceAddedEvent>{ url: url, addedElement: element });
-	}
+	public insert(uri:URI, element:IMirrorModel): void {
+		let key = uri.toString();
 
-	public get(url:URI):IMirrorModel {
-		if(!this.data[url.toString()]) {
-			return null;
+		if (this._map.contains(key)) {
+			// There already exists a model with this id => this is a programmer error
+			throw new Error('ResourceService: Cannot add model ' + ResourceService._anonymousModelId(key) + ' because it already exists!');
 		}
-		return this.data[url.toString()];
+		this._map.set(key, element);
 	}
 
-	public all():IMirrorModel[] {
-		return Object.keys(this.data).map((key) => {
-			return this.data[key];
-		});
-	}
+	public get(uri:URI):IMirrorModel {
+		let key = uri.toString();
 
-	public contains(url:URI):boolean {
-		return !!this.data[url.toString()];
+		return this._map.get(key);
 	}
 
-	public remove(url:URI):void {
-		// console.log('REMOVE: ' + url.toString());
-		if(!this.contains(url)) {
-			return;
-		}
-
-		var key = url.toString(),
-			element = this.data[key];
-
-		// stop listen
-		this.unbinds[key] = dispose(this.unbinds[key]);
-
-		// removal
-		delete this.unbinds[key];
-		delete this.data[key];
+	public remove(uri:URI):void {
+		let key = uri.toString();
 
-		// event
-		this.emit(ResourceEvents.REMOVED, <IResourceRemovedEvent>{ url: url, removedElement: element });
+		this._map.remove(key);
 	}
 }

src/vs/editor/test/common/services/resourceService.test.ts

@@ -7,72 +7,33 @@
 import * as assert from 'assert';
 import URI from 'vs/base/common/uri';
 import {createTestMirrorModelFromString} from 'vs/editor/common/model/mirrorModel';
-import {ResourceEvents} from 'vs/editor/common/services/resourceService';
 import {ResourceService} from 'vs/editor/common/services/resourceServiceImpl';
 
 suite('Editor Services - ResourceService', () => {
 
 	test('insert, remove, all', () => {
 
-		var service = new ResourceService();
+		let service = new ResourceService();
 
 		service.insert(URI.parse('test://1'), createTestMirrorModelFromString('hi'));
-		assert.equal(service.all().length, 1);
+		assert.equal(service.get(URI.parse('test://1')).getValue(), 'hi');
 
 		service.insert(URI.parse('test://2'), createTestMirrorModelFromString('hi'));
-		assert.equal(service.all().length, 2);
-
-		assert.ok(service.contains(URI.parse('test://1')));
-		assert.ok(service.contains(URI.parse('test://2')));
 
 		service.remove(URI.parse('test://1'));
 		service.remove(URI.parse('test://1'));
 		service.remove(URI.parse('test://2'));
-		assert.equal(service.all().length, 0);
-	});
-
-
-	test('event - add, remove', () => {
-
-		var eventCnt = 0;
-
-		var url = URI.parse('far');
-		var element = createTestMirrorModelFromString('hi');
-		var service = new ResourceService();
-		service.addListener2(ResourceEvents.ADDED, () => {
-			eventCnt++;
-			assert.ok(true);
-		});
-		service.addListener2(ResourceEvents.REMOVED, () => {
-			eventCnt++;
-			assert.ok(true);
-		});
 
-		service.insert(url, element);
-		service.remove(url);
-		assert.equal(eventCnt, 2, 'events');
+		assert.equal(service.get(URI.parse('test://1')), null);
 	});
 
-	test('event - propagation', () => {
-
-		var eventCnt = 0;
+	test('inserting the same resource twice throws', () => {
+		let service = new ResourceService();
 
-		var url = URI.parse('far');
-		var element = createTestMirrorModelFromString('hi');
-		var event = {};
+		service.insert(URI.parse('test://path/some-N1ce-name'), createTestMirrorModelFromString('hello'));
 
-		var service = new ResourceService();
-		service.insert(url, element);
-
-		service.addBulkListener2((events) => {
-			eventCnt++;
-			assert.equal(events.length, 1);
-			assert.equal(events[0].getData().originalEvents.length, 1);
-			assert.ok(events[0].getData().originalEvents[0].getData() === event);
+		assert.throws(() => {
+			service.insert(URI.parse('test://path/some-N1ce-name'), createTestMirrorModelFromString('hello again'));
 		});
-
-		element.emit('changed', event);
-		assert.equal(eventCnt, 1, 'events');
 	});
-
 });