Adjust editor config (#976)

* Adjust editor config

Signed-off-by: Tilman Vatteroth <tilman.vatteroth@tu-dortmund.de>
Co-authored-by: Erik Michelson <github@erik.michelson.eu>

src/components/common/cache/cache.test.ts

@@ -16,68 +16,88 @@ describe('Test caching functionality', () => {
   it('initialize with right lifetime, no entry limit', () => {
     const lifetime = 1000
     const lifetimedCache = new Cache<string, string>(lifetime)
-    expect(lifetimedCache.entryLifetime).toEqual(lifetime)
-    expect(lifetimedCache.maxEntries).toEqual(0)
+    expect(lifetimedCache.entryLifetime)
+      .toEqual(lifetime)
+    expect(lifetimedCache.maxEntries)
+      .toEqual(0)
   })
 
   it('initialize with right lifetime, given entry limit', () => {
     const lifetime = 1000
     const maxEntries = 10
     const limitedCache = new Cache<string, string>(lifetime, maxEntries)
-    expect(limitedCache.entryLifetime).toEqual(lifetime)
-    expect(limitedCache.maxEntries).toEqual(maxEntries)
+    expect(limitedCache.entryLifetime)
+      .toEqual(lifetime)
+    expect(limitedCache.maxEntries)
+      .toEqual(maxEntries)
   })
 
   it('entry exists after inserting', () => {
     testCache.put('test', 123)
-    expect(testCache.has('test')).toBe(true)
+    expect(testCache.has('test'))
+      .toBe(true)
   })
 
   it('entry does not exist prior inserting', () => {
-    expect(testCache.has('test')).toBe(false)
+    expect(testCache.has('test'))
+      .toBe(false)
   })
 
   it('entry does expire', () => {
     const shortLivingCache = new Cache<string, number>(2)
     shortLivingCache.put('test', 123)
-    expect(shortLivingCache.has('test')).toBe(true)
+    expect(shortLivingCache.has('test'))
+      .toBe(true)
     setTimeout(() => {
-      expect(shortLivingCache.has('test')).toBe(false)
+      expect(shortLivingCache.has('test'))
+        .toBe(false)
     }, 2000)
   })
 
   it('entry value does not change', () => {
     const testValue = Date.now()
     testCache.put('test', testValue)
-    expect(testCache.get('test')).toEqual(testValue)
+    expect(testCache.get('test'))
+      .toEqual(testValue)
   })
 
   it('error is thrown on non-existent entry', () => {
     const accessNonExistentEntry = () => {
       testCache.get('test')
     }
-    expect(accessNonExistentEntry).toThrow(Error)
+    expect(accessNonExistentEntry)
+      .toThrow(Error)
   })
 
   it('newer item replaces older item', () => {
     testCache.put('test', 123)
     testCache.put('test', 456)
-    expect(testCache.get('test')).toEqual(456)
+    expect(testCache.get('test'))
+      .toEqual(456)
   })
 
   it('entry limit is respected', () => {
     const limitedCache = new Cache<string, number>(1000, 2)
     limitedCache.put('first', 1)
-    expect(limitedCache.has('first')).toBe(true)
-    expect(limitedCache.has('second')).toBe(false)
-    expect(limitedCache.has('third')).toBe(false)
+    expect(limitedCache.has('first'))
+      .toBe(true)
+    expect(limitedCache.has('second'))
+      .toBe(false)
+    expect(limitedCache.has('third'))
+      .toBe(false)
     limitedCache.put('second', 2)
-    expect(limitedCache.has('first')).toBe(true)
-    expect(limitedCache.has('second')).toBe(true)
-    expect(limitedCache.has('third')).toBe(false)
+    expect(limitedCache.has('first'))
+      .toBe(true)
+    expect(limitedCache.has('second'))
+      .toBe(true)
+    expect(limitedCache.has('third'))
+      .toBe(false)
     limitedCache.put('third', 3)
-    expect(limitedCache.has('first')).toBe(false)
-    expect(limitedCache.has('second')).toBe(true)
-    expect(limitedCache.has('third')).toBe(true)
+    expect(limitedCache.has('first'))
+      .toBe(false)
+    expect(limitedCache.has('second'))
+      .toBe(true)
+    expect(limitedCache.has('third'))
+      .toBe(true)
   })
 })

src/components/common/cache/cache.ts

@@ -10,12 +10,11 @@ export interface CacheEntry<T> {
 }
 
 export class Cache<K, V> {
-  private store = new Map<K, CacheEntry<V>>()
-
   readonly entryLifetime: number
   readonly maxEntries: number
+  private store = new Map<K, CacheEntry<V>>()
 
-  constructor (lifetime: number, maxEntries = 0) {
+  constructor(lifetime: number, maxEntries = 0) {
     if (lifetime < 0) {
       throw new Error('Cache entry lifetime can not be less than 0 seconds.')
     }
@@ -23,7 +22,7 @@ export class Cache<K, V> {
     this.maxEntries = maxEntries
   }
 
-  has (key: K): boolean {
+  has(key: K): boolean {
     if (!this.store.has(key)) {
       return false
     }
@@ -31,7 +30,7 @@ export class Cache<K, V> {
     return (!!entry && entry.entryCreated >= (Date.now() - this.entryLifetime * 1000))
   }
 
-  get (key: K): V {
+  get(key: K): V {
     const entry = this.store.get(key)
     if (!entry) {
       throw new Error('This cache entry does not exist. Check with ".has()" before using ".get()".')
@@ -39,9 +38,10 @@ export class Cache<K, V> {
     return entry.data
   }
 
-  put (key: K, value: V): void {
+  put(key: K, value: V): void {
     if (this.maxEntries > 0 && this.store.size === this.maxEntries) {
-      this.store.delete(this.store.keys().next().value)
+      this.store.delete(this.store.keys()
+                            .next().value)
     }
     this.store.set(key, {
       entryCreated: Date.now(),